hotspot/src/os/linux/vm/os_linux.cpp
author phh
Wed, 05 Dec 2007 09:04:00 -0800
changeset 193 171c404abf72
parent 1 489c9b5090e2
child 235 735f15bdea80
permissions -rw-r--r--
6629887: 64-bit windows should not restrict default heap size to 1400m Reviewed-by: jmasa, sbohne, ikrylov, xlu
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
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1264
jlong os::timeofday() {
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
// Must return millis since Jan 1 1970 for JVM_CurrentTimeMillis
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1272
// _use_global_time is only set if CacheTimeMillis is true
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1273
jlong os::javaTimeMillis() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1274
  return (_use_global_time ? read_global_time() : timeofday());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1275
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1276
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1277
#ifndef CLOCK_MONOTONIC
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1278
#define CLOCK_MONOTONIC (1)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1279
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1280
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1281
void os::Linux::clock_init() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1282
  // we do dlopen's in this particular order due to bug in linux
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1283
  // dynamical loader (see 6348968) leading to crash on exit
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1284
  void* handle = dlopen("librt.so.1", RTLD_LAZY);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1285
  if (handle == NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1286
    handle = dlopen("librt.so", RTLD_LAZY);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1287
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1288
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1289
  if (handle) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1290
    int (*clock_getres_func)(clockid_t, struct timespec*) =
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1291
           (int(*)(clockid_t, struct timespec*))dlsym(handle, "clock_getres");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1292
    int (*clock_gettime_func)(clockid_t, struct timespec*) =
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1293
           (int(*)(clockid_t, struct timespec*))dlsym(handle, "clock_gettime");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1294
    if (clock_getres_func && clock_gettime_func) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1295
      // See if monotonic clock is supported by the kernel. Note that some
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1296
      // early implementations simply return kernel jiffies (updated every
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1297
      // 1/100 or 1/1000 second). It would be bad to use such a low res clock
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1298
      // for nano time (though the monotonic property is still nice to have).
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1299
      // It's fixed in newer kernels, however clock_getres() still returns
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1300
      // 1/HZ. We check if clock_getres() works, but will ignore its reported
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1301
      // resolution for now. Hopefully as people move to new kernels, this
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1302
      // won't be a problem.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1303
      struct timespec res;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1304
      struct timespec tp;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1305
      if (clock_getres_func (CLOCK_MONOTONIC, &res) == 0 &&
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1306
          clock_gettime_func(CLOCK_MONOTONIC, &tp)  == 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1307
        // yes, monotonic clock is supported
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1308
        _clock_gettime = clock_gettime_func;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1309
      } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1310
        // close librt if there is no monotonic clock
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1311
        dlclose(handle);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1312
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1313
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1314
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1315
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1316
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1317
#ifndef SYS_clock_getres
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1318
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1319
#if defined(IA32) || defined(AMD64)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1320
#define SYS_clock_getres IA32_ONLY(266)  AMD64_ONLY(229)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1321
#else
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1322
#error Value of SYS_clock_getres not known on this platform
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1323
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1324
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1325
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1326
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1327
#define sys_clock_getres(x,y)  ::syscall(SYS_clock_getres, x, y)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1328
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1329
void os::Linux::fast_thread_clock_init() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1330
  if (!UseLinuxPosixThreadCPUClocks) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1331
    return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1332
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1333
  clockid_t clockid;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1334
  struct timespec tp;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1335
  int (*pthread_getcpuclockid_func)(pthread_t, clockid_t *) =
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1336
      (int(*)(pthread_t, clockid_t *)) dlsym(RTLD_DEFAULT, "pthread_getcpuclockid");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1337
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1338
  // Switch to using fast clocks for thread cpu time if
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1339
  // the sys_clock_getres() returns 0 error code.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1340
  // Note, that some kernels may support the current thread
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1341
  // clock (CLOCK_THREAD_CPUTIME_ID) but not the clocks
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1342
  // returned by the pthread_getcpuclockid().
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1343
  // If the fast Posix clocks are supported then the sys_clock_getres()
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1344
  // must return at least tp.tv_sec == 0 which means a resolution
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1345
  // better than 1 sec. This is extra check for reliability.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1346
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1347
  if(pthread_getcpuclockid_func &&
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1348
     pthread_getcpuclockid_func(_main_thread, &clockid) == 0 &&
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1349
     sys_clock_getres(clockid, &tp) == 0 && tp.tv_sec == 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1350
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1351
    _supports_fast_thread_cpu_time = true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1352
    _pthread_getcpuclockid = pthread_getcpuclockid_func;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1353
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1354
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1355
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1356
jlong os::javaTimeNanos() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1357
  if (Linux::supports_monotonic_clock()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1358
    struct timespec tp;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1359
    int status = Linux::clock_gettime(CLOCK_MONOTONIC, &tp);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1360
    assert(status == 0, "gettime error");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1361
    jlong result = jlong(tp.tv_sec) * (1000 * 1000 * 1000) + jlong(tp.tv_nsec);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1362
    return result;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1363
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1364
    timeval time;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1365
    int status = gettimeofday(&time, NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1366
    assert(status != -1, "linux error");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1367
    jlong usecs = jlong(time.tv_sec) * (1000 * 1000) + jlong(time.tv_usec);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1368
    return 1000 * usecs;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1369
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1370
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1371
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1372
void os::javaTimeNanos_info(jvmtiTimerInfo *info_ptr) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1373
  if (Linux::supports_monotonic_clock()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1374
    info_ptr->max_value = ALL_64_BITS;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1375
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1376
    // CLOCK_MONOTONIC - amount of time since some arbitrary point in the past
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1377
    info_ptr->may_skip_backward = false;      // not subject to resetting or drifting
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1378
    info_ptr->may_skip_forward = false;       // not subject to resetting or drifting
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1379
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1380
    // gettimeofday - based on time in seconds since the Epoch thus does not wrap
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1381
    info_ptr->max_value = ALL_64_BITS;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1382
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1383
    // gettimeofday is a real time clock so it skips
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1384
    info_ptr->may_skip_backward = true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1385
    info_ptr->may_skip_forward = true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1386
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1387
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1388
  info_ptr->kind = JVMTI_TIMER_ELAPSED;                // elapsed not CPU time
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1389
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1390
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1391
// Return the real, user, and system times in seconds from an
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1392
// arbitrary fixed point in the past.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1393
bool os::getTimesSecs(double* process_real_time,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1394
                      double* process_user_time,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1395
                      double* process_system_time) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1396
  struct tms ticks;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1397
  clock_t real_ticks = times(&ticks);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1398
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1399
  if (real_ticks == (clock_t) (-1)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1400
    return false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1401
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1402
    double ticks_per_second = (double) clock_tics_per_sec;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1403
    *process_user_time = ((double) ticks.tms_utime) / ticks_per_second;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1404
    *process_system_time = ((double) ticks.tms_stime) / ticks_per_second;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1405
    *process_real_time = ((double) real_ticks) / ticks_per_second;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1406
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1407
    return true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1408
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1409
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1410
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1411
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1412
char * os::local_time_string(char *buf, size_t buflen) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1413
  struct tm t;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1414
  time_t long_time;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1415
  time(&long_time);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1416
  localtime_r(&long_time, &t);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1417
  jio_snprintf(buf, buflen, "%d-%02d-%02d %02d:%02d:%02d",
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1418
               t.tm_year + 1900, t.tm_mon + 1, t.tm_mday,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1419
               t.tm_hour, t.tm_min, t.tm_sec);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1420
  return buf;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1421
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1422
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1423
////////////////////////////////////////////////////////////////////////////////
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1424
// runtime exit support
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1425
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1426
// Note: os::shutdown() might be called very early during initialization, or
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1427
// called from signal handler. Before adding something to os::shutdown(), make
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1428
// sure it is async-safe and can handle partially initialized VM.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1429
void os::shutdown() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1430
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1431
  // allow PerfMemory to attempt cleanup of any persistent resources
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1432
  perfMemory_exit();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1433
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1434
  // needs to remove object in file system
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1435
  AttachListener::abort();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1436
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1437
  // flush buffered output, finish log files
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1438
  ostream_abort();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1439
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1440
  // Check for abort hook
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1441
  abort_hook_t abort_hook = Arguments::abort_hook();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1442
  if (abort_hook != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1443
    abort_hook();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1444
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1445
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1446
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1447
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1448
// Note: os::abort() might be called very early during initialization, or
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1449
// called from signal handler. Before adding something to os::abort(), make
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1450
// sure it is async-safe and can handle partially initialized VM.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1451
void os::abort(bool dump_core) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1452
  os::shutdown();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1453
  if (dump_core) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1454
#ifndef PRODUCT
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1455
    fdStream out(defaultStream::output_fd());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1456
    out.print_raw("Current thread is ");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1457
    char buf[16];
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1458
    jio_snprintf(buf, sizeof(buf), UINTX_FORMAT, os::current_thread_id());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1459
    out.print_raw_cr(buf);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1460
    out.print_raw_cr("Dumping core ...");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1461
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1462
    ::abort(); // dump core
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1463
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1464
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1465
  ::exit(1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1466
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1467
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1468
// Die immediately, no exit hook, no abort hook, no cleanup.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1469
void os::die() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1470
  // _exit() on LinuxThreads only kills current thread
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1471
  ::abort();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1472
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1473
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1474
// unused on linux for now.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1475
void os::set_error_file(const char *logfile) {}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1476
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1477
intx os::current_thread_id() { return (intx)pthread_self(); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1478
int os::current_process_id() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1479
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1480
  // Under the old linux thread library, linux gives each thread
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1481
  // its own process id. Because of this each thread will return
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1482
  // a different pid if this method were to return the result
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1483
  // of getpid(2). Linux provides no api that returns the pid
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1484
  // of the launcher thread for the vm. This implementation
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1485
  // returns a unique pid, the pid of the launcher thread
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1486
  // that starts the vm 'process'.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1487
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1488
  // Under the NPTL, getpid() returns the same pid as the
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1489
  // launcher thread rather than a unique pid per thread.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1490
  // Use gettid() if you want the old pre NPTL behaviour.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1491
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1492
  // if you are looking for the result of a call to getpid() that
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1493
  // returns a unique pid for the calling thread, then look at the
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1494
  // OSThread::thread_id() method in osThread_linux.hpp file
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1495
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1496
  return (int)(_initial_pid ? _initial_pid : getpid());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1497
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1498
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1499
// DLL functions
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1500
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1501
const char* os::dll_file_extension() { return ".so"; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1502
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1503
const char* os::get_temp_directory() { return "/tmp/"; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1504
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1505
const char* os::get_current_directory(char *buf, int buflen) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1506
  return getcwd(buf, buflen);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1507
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1508
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1509
// check if addr is inside libjvm[_g].so
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1510
bool os::address_is_in_vm(address addr) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1511
  static address libjvm_base_addr;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1512
  Dl_info dlinfo;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1513
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1514
  if (libjvm_base_addr == NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1515
    dladdr(CAST_FROM_FN_PTR(void *, os::address_is_in_vm), &dlinfo);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1516
    libjvm_base_addr = (address)dlinfo.dli_fbase;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1517
    assert(libjvm_base_addr !=NULL, "Cannot obtain base address for libjvm");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1518
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1519
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1520
  if (dladdr((void *)addr, &dlinfo)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1521
    if (libjvm_base_addr == (address)dlinfo.dli_fbase) return true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1522
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1523
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1524
  return false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1525
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1526
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1527
bool os::dll_address_to_function_name(address addr, char *buf,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1528
                                      int buflen, int *offset) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1529
  Dl_info dlinfo;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1530
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1531
  if (dladdr((void*)addr, &dlinfo) && dlinfo.dli_sname != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1532
    if (buf) jio_snprintf(buf, buflen, "%s", dlinfo.dli_sname);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1533
    if (offset) *offset = addr - (address)dlinfo.dli_saddr;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1534
    return true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1535
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1536
    if (buf) buf[0] = '\0';
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1537
    if (offset) *offset = -1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1538
    return false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1539
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1540
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1541
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1542
struct _address_to_library_name {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1543
  address addr;          // input : memory address
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1544
  size_t  buflen;        //         size of fname
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1545
  char*   fname;         // output: library name
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1546
  address base;          //         library base addr
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1547
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1548
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1549
static int address_to_library_name_callback(struct dl_phdr_info *info,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1550
                                            size_t size, void *data) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1551
  int i;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1552
  bool found = false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1553
  address libbase = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1554
  struct _address_to_library_name * d = (struct _address_to_library_name *)data;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1555
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1556
  // iterate through all loadable segments
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1557
  for (i = 0; i < info->dlpi_phnum; i++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1558
    address segbase = (address)(info->dlpi_addr + info->dlpi_phdr[i].p_vaddr);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1559
    if (info->dlpi_phdr[i].p_type == PT_LOAD) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1560
      // base address of a library is the lowest address of its loaded
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1561
      // segments.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1562
      if (libbase == NULL || libbase > segbase) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1563
        libbase = segbase;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1564
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1565
      // see if 'addr' is within current segment
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1566
      if (segbase <= d->addr &&
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1567
          d->addr < segbase + info->dlpi_phdr[i].p_memsz) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1568
        found = true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1569
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1570
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1571
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1572
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1573
  // dlpi_name is NULL or empty if the ELF file is executable, return 0
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1574
  // so dll_address_to_library_name() can fall through to use dladdr() which
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1575
  // can figure out executable name from argv[0].
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1576
  if (found && info->dlpi_name && info->dlpi_name[0]) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1577
    d->base = libbase;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1578
    if (d->fname) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1579
      jio_snprintf(d->fname, d->buflen, "%s", info->dlpi_name);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1580
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1581
    return 1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1582
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1583
  return 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1584
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1585
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1586
bool os::dll_address_to_library_name(address addr, char* buf,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1587
                                     int buflen, int* offset) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1588
  Dl_info dlinfo;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1589
  struct _address_to_library_name data;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1590
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1591
  // There is a bug in old glibc dladdr() implementation that it could resolve
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1592
  // to wrong library name if the .so file has a base address != NULL. Here
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1593
  // we iterate through the program headers of all loaded libraries to find
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1594
  // out which library 'addr' really belongs to. This workaround can be
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1595
  // removed once the minimum requirement for glibc is moved to 2.3.x.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1596
  data.addr = addr;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1597
  data.fname = buf;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1598
  data.buflen = buflen;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1599
  data.base = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1600
  int rslt = dl_iterate_phdr(address_to_library_name_callback, (void *)&data);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1601
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1602
  if (rslt) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1603
     // buf already contains library name
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1604
     if (offset) *offset = addr - data.base;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1605
     return true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1606
  } else if (dladdr((void*)addr, &dlinfo)){
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1607
     if (buf) jio_snprintf(buf, buflen, "%s", dlinfo.dli_fname);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1608
     if (offset) *offset = addr - (address)dlinfo.dli_fbase;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1609
     return true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1610
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1611
     if (buf) buf[0] = '\0';
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1612
     if (offset) *offset = -1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1613
     return false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1614
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1615
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1616
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1617
  // Loads .dll/.so and
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1618
  // in case of error it checks if .dll/.so was built for the
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1619
  // same architecture as Hotspot is running on
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1620
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1621
void * os::dll_load(const char *filename, char *ebuf, int ebuflen)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1622
{
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1623
  void * result= ::dlopen(filename, RTLD_LAZY);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1624
  if (result != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1625
    // Successful loading
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1626
    return result;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1627
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1628
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1629
  Elf32_Ehdr elf_head;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1630
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1631
  // Read system error message into ebuf
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1632
  // It may or may not be overwritten below
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1633
  ::strncpy(ebuf, ::dlerror(), ebuflen-1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1634
  ebuf[ebuflen-1]='\0';
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1635
  int diag_msg_max_length=ebuflen-strlen(ebuf);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1636
  char* diag_msg_buf=ebuf+strlen(ebuf);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1637
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1638
  if (diag_msg_max_length==0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1639
    // No more space in ebuf for additional diagnostics message
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1640
    return NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1641
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1642
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1643
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1644
  int file_descriptor= ::open(filename, O_RDONLY | O_NONBLOCK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1645
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1646
  if (file_descriptor < 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1647
    // Can't open library, report dlerror() message
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1648
    return NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1649
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1650
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1651
  bool failed_to_read_elf_head=
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1652
    (sizeof(elf_head)!=
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1653
        (::read(file_descriptor, &elf_head,sizeof(elf_head)))) ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1654
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1655
  ::close(file_descriptor);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1656
  if (failed_to_read_elf_head) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1657
    // file i/o error - report dlerror() msg
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1658
    return NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1659
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1660
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1661
  typedef struct {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1662
    Elf32_Half  code;         // Actual value as defined in elf.h
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1663
    Elf32_Half  compat_class; // Compatibility of archs at VM's sense
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1664
    char        elf_class;    // 32 or 64 bit
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1665
    char        endianess;    // MSB or LSB
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1666
    char*       name;         // String representation
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1667
  } arch_t;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1668
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1669
  #ifndef EM_486
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1670
  #define EM_486          6               /* Intel 80486 */
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1671
  #endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1672
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1673
  static const arch_t arch_array[]={
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1674
    {EM_386,         EM_386,     ELFCLASS32, ELFDATA2LSB, (char*)"IA 32"},
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1675
    {EM_486,         EM_386,     ELFCLASS32, ELFDATA2LSB, (char*)"IA 32"},
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1676
    {EM_IA_64,       EM_IA_64,   ELFCLASS64, ELFDATA2LSB, (char*)"IA 64"},
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1677
    {EM_X86_64,      EM_X86_64,  ELFCLASS64, ELFDATA2LSB, (char*)"AMD 64"},
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1678
    {EM_SPARC,       EM_SPARC,   ELFCLASS32, ELFDATA2MSB, (char*)"Sparc 32"},
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1679
    {EM_SPARC32PLUS, EM_SPARC,   ELFCLASS32, ELFDATA2MSB, (char*)"Sparc 32"},
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1680
    {EM_SPARCV9,     EM_SPARCV9, ELFCLASS64, ELFDATA2MSB, (char*)"Sparc v9 64"},
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1681
    {EM_PPC,         EM_PPC,     ELFCLASS32, ELFDATA2MSB, (char*)"Power PC 32"},
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1682
    {EM_PPC64,       EM_PPC64,   ELFCLASS64, ELFDATA2MSB, (char*)"Power PC 64"}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1683
  };
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1684
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1685
  #if  (defined IA32)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1686
    static  Elf32_Half running_arch_code=EM_386;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1687
  #elif   (defined AMD64)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1688
    static  Elf32_Half running_arch_code=EM_X86_64;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1689
  #elif  (defined IA64)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1690
    static  Elf32_Half running_arch_code=EM_IA_64;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1691
  #elif  (defined __sparc) && (defined _LP64)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1692
    static  Elf32_Half running_arch_code=EM_SPARCV9;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1693
  #elif  (defined __sparc) && (!defined _LP64)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1694
    static  Elf32_Half running_arch_code=EM_SPARC;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1695
  #elif  (defined __powerpc64__)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1696
    static  Elf32_Half running_arch_code=EM_PPC64;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1697
  #elif  (defined __powerpc__)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1698
    static  Elf32_Half running_arch_code=EM_PPC;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1699
  #else
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1700
    #error Method os::dll_load requires that one of following is defined:\
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1701
         IA32, AMD64, IA64, __sparc, __powerpc__
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1702
  #endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1703
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1704
  // Identify compatability class for VM's architecture and library's architecture
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1705
  // Obtain string descriptions for architectures
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1706
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1707
  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
  1708
  int running_arch_index=-1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1709
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1710
  for (unsigned int i=0 ; i < ARRAY_SIZE(arch_array) ; i++ ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1711
    if (running_arch_code == arch_array[i].code) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1712
      running_arch_index    = i;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1713
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1714
    if (lib_arch.code == arch_array[i].code) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1715
      lib_arch.compat_class = arch_array[i].compat_class;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1716
      lib_arch.name         = arch_array[i].name;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1717
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1718
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1719
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1720
  assert(running_arch_index != -1,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1721
    "Didn't find running architecture code (running_arch_code) in arch_array");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1722
  if (running_arch_index == -1) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1723
    // Even though running architecture detection failed
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1724
    // we may still continue with reporting dlerror() message
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1725
    return NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1726
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1727
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1728
  if (lib_arch.endianess != arch_array[running_arch_index].endianess) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1729
    ::snprintf(diag_msg_buf, diag_msg_max_length-1," (Possible cause: endianness mismatch)");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1730
    return NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1731
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1732
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1733
  if (lib_arch.elf_class != arch_array[running_arch_index].elf_class) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1734
    ::snprintf(diag_msg_buf, diag_msg_max_length-1," (Possible cause: architecture word width mismatch)");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1735
    return NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1736
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1737
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1738
  if (lib_arch.compat_class != arch_array[running_arch_index].compat_class) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1739
    if ( lib_arch.name!=NULL ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1740
      ::snprintf(diag_msg_buf, diag_msg_max_length-1,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1741
        " (Possible cause: can't load %s-bit .so on a %s-bit platform)",
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1742
        lib_arch.name, arch_array[running_arch_index].name);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1743
    } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1744
      ::snprintf(diag_msg_buf, diag_msg_max_length-1,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1745
      " (Possible cause: can't load this .so (machine code=0x%x) on a %s-bit platform)",
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1746
        lib_arch.code,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1747
        arch_array[running_arch_index].name);
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
  return NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1752
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1753
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1754
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1755
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1756
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1757
bool _print_ascii_file(const char* filename, outputStream* st) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1758
  int fd = open(filename, O_RDONLY);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1759
  if (fd == -1) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1760
     return false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1761
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1762
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1763
  char buf[32];
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1764
  int bytes;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1765
  while ((bytes = read(fd, buf, sizeof(buf))) > 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1766
    st->print_raw(buf, bytes);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1767
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1768
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1769
  close(fd);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1770
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1771
  return true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1772
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1773
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1774
void os::print_dll_info(outputStream *st) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1775
   st->print_cr("Dynamic libraries:");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1776
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1777
   char fname[32];
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1778
   pid_t pid = os::Linux::gettid();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1779
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1780
   jio_snprintf(fname, sizeof(fname), "/proc/%d/maps", pid);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1781
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1782
   if (!_print_ascii_file(fname, st)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1783
     st->print("Can not get library information for pid = %d\n", pid);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1784
   }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1785
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1786
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1787
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1788
void os::print_os_info(outputStream* st) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1789
  st->print("OS:");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1790
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1791
  // Try to identify popular distros.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1792
  // Most Linux distributions have /etc/XXX-release file, which contains
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1793
  // the OS version string. Some have more than one /etc/XXX-release file
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1794
  // (e.g. Mandrake has both /etc/mandrake-release and /etc/redhat-release.),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1795
  // so the order is important.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1796
  if (!_print_ascii_file("/etc/mandrake-release", st) &&
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1797
      !_print_ascii_file("/etc/sun-release", st) &&
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1798
      !_print_ascii_file("/etc/redhat-release", st) &&
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1799
      !_print_ascii_file("/etc/SuSE-release", st) &&
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1800
      !_print_ascii_file("/etc/turbolinux-release", st) &&
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1801
      !_print_ascii_file("/etc/gentoo-release", st) &&
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1802
      !_print_ascii_file("/etc/debian_version", st)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1803
      st->print("Linux");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1804
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1805
  st->cr();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1806
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1807
  // kernel
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1808
  st->print("uname:");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1809
  struct utsname name;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1810
  uname(&name);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1811
  st->print(name.sysname); st->print(" ");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1812
  st->print(name.release); st->print(" ");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1813
  st->print(name.version); st->print(" ");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1814
  st->print(name.machine);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1815
  st->cr();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1816
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1817
  // Print warning if unsafe chroot environment detected
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1818
  if (unsafe_chroot_detected) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1819
    st->print("WARNING!! ");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1820
    st->print_cr(unstable_chroot_error);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1821
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1822
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1823
  // libc, pthread
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1824
  st->print("libc:");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1825
  st->print(os::Linux::glibc_version()); st->print(" ");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1826
  st->print(os::Linux::libpthread_version()); st->print(" ");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1827
  if (os::Linux::is_LinuxThreads()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1828
     st->print("(%s stack)", os::Linux::is_floating_stack() ? "floating" : "fixed");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1829
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1830
  st->cr();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1831
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1832
  // rlimit
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1833
  st->print("rlimit:");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1834
  struct rlimit rlim;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1835
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1836
  st->print(" STACK ");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1837
  getrlimit(RLIMIT_STACK, &rlim);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1838
  if (rlim.rlim_cur == RLIM_INFINITY) st->print("infinity");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1839
  else st->print("%uk", rlim.rlim_cur >> 10);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1840
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1841
  st->print(", CORE ");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1842
  getrlimit(RLIMIT_CORE, &rlim);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1843
  if (rlim.rlim_cur == RLIM_INFINITY) st->print("infinity");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1844
  else st->print("%uk", rlim.rlim_cur >> 10);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1845
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1846
  st->print(", NPROC ");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1847
  getrlimit(RLIMIT_NPROC, &rlim);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1848
  if (rlim.rlim_cur == RLIM_INFINITY) st->print("infinity");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1849
  else st->print("%d", rlim.rlim_cur);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1850
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1851
  st->print(", NOFILE ");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1852
  getrlimit(RLIMIT_NOFILE, &rlim);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1853
  if (rlim.rlim_cur == RLIM_INFINITY) st->print("infinity");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1854
  else st->print("%d", rlim.rlim_cur);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1855
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1856
  st->print(", AS ");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1857
  getrlimit(RLIMIT_AS, &rlim);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1858
  if (rlim.rlim_cur == RLIM_INFINITY) st->print("infinity");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1859
  else st->print("%uk", rlim.rlim_cur >> 10);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1860
  st->cr();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1861
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1862
  // load average
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1863
  st->print("load average:");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1864
  double loadavg[3];
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1865
  os::loadavg(loadavg, 3);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1866
  st->print("%0.02f %0.02f %0.02f", loadavg[0], loadavg[1], loadavg[2]);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1867
  st->cr();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1868
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1869
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1870
void os::print_memory_info(outputStream* st) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1871
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1872
  st->print("Memory:");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1873
  st->print(" %dk page", os::vm_page_size()>>10);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1874
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1875
  // values in struct sysinfo are "unsigned long"
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1876
  struct sysinfo si;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1877
  sysinfo(&si);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1878
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1879
  st->print(", physical " UINT64_FORMAT "k",
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1880
            os::physical_memory() >> 10);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1881
  st->print("(" UINT64_FORMAT "k free)",
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1882
            os::available_memory() >> 10);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1883
  st->print(", swap " UINT64_FORMAT "k",
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1884
            ((jlong)si.totalswap * si.mem_unit) >> 10);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1885
  st->print("(" UINT64_FORMAT "k free)",
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1886
            ((jlong)si.freeswap * si.mem_unit) >> 10);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1887
  st->cr();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1888
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1889
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1890
// Taken from /usr/include/bits/siginfo.h  Supposed to be architecture specific
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1891
// but they're the same for all the linux arch that we support
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1892
// and they're the same for solaris but there's no common place to put this.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1893
const char *ill_names[] = { "ILL0", "ILL_ILLOPC", "ILL_ILLOPN", "ILL_ILLADR",
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1894
                          "ILL_ILLTRP", "ILL_PRVOPC", "ILL_PRVREG",
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1895
                          "ILL_COPROC", "ILL_BADSTK" };
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1896
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1897
const char *fpe_names[] = { "FPE0", "FPE_INTDIV", "FPE_INTOVF", "FPE_FLTDIV",
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1898
                          "FPE_FLTOVF", "FPE_FLTUND", "FPE_FLTRES",
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1899
                          "FPE_FLTINV", "FPE_FLTSUB", "FPE_FLTDEN" };
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1900
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1901
const char *segv_names[] = { "SEGV0", "SEGV_MAPERR", "SEGV_ACCERR" };
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1902
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1903
const char *bus_names[] = { "BUS0", "BUS_ADRALN", "BUS_ADRERR", "BUS_OBJERR" };
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1904
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1905
void os::print_siginfo(outputStream* st, void* siginfo) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1906
  st->print("siginfo:");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1907
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1908
  const int buflen = 100;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1909
  char buf[buflen];
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1910
  siginfo_t *si = (siginfo_t*)siginfo;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1911
  st->print("si_signo=%s: ", os::exception_name(si->si_signo, buf, buflen));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1912
  if (si->si_errno != 0 && strerror_r(si->si_errno, buf, buflen) == 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1913
    st->print("si_errno=%s", buf);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1914
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1915
    st->print("si_errno=%d", si->si_errno);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1916
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1917
  const int c = si->si_code;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1918
  assert(c > 0, "unexpected si_code");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1919
  switch (si->si_signo) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1920
  case SIGILL:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1921
    st->print(", si_code=%d (%s)", c, c > 8 ? "" : ill_names[c]);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1922
    st->print(", si_addr=" PTR_FORMAT, si->si_addr);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1923
    break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1924
  case SIGFPE:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1925
    st->print(", si_code=%d (%s)", c, c > 9 ? "" : fpe_names[c]);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1926
    st->print(", si_addr=" PTR_FORMAT, si->si_addr);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1927
    break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1928
  case SIGSEGV:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1929
    st->print(", si_code=%d (%s)", c, c > 2 ? "" : segv_names[c]);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1930
    st->print(", si_addr=" PTR_FORMAT, si->si_addr);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1931
    break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1932
  case SIGBUS:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1933
    st->print(", si_code=%d (%s)", c, c > 3 ? "" : bus_names[c]);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1934
    st->print(", si_addr=" PTR_FORMAT, si->si_addr);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1935
    break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1936
  default:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1937
    st->print(", si_code=%d", si->si_code);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1938
    // no si_addr
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1939
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1940
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1941
  if ((si->si_signo == SIGBUS || si->si_signo == SIGSEGV) &&
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1942
      UseSharedSpaces) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1943
    FileMapInfo* mapinfo = FileMapInfo::current_info();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1944
    if (mapinfo->is_in_shared_space(si->si_addr)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1945
      st->print("\n\nError accessing class data sharing archive."   \
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1946
                " Mapped file inaccessible during execution, "      \
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1947
                " possible disk/network problem.");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1948
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1949
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1950
  st->cr();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1951
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1952
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1953
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1954
static void print_signal_handler(outputStream* st, int sig,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1955
                                 char* buf, size_t buflen);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1956
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1957
void os::print_signal_handlers(outputStream* st, char* buf, size_t buflen) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1958
  st->print_cr("Signal Handlers:");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1959
  print_signal_handler(st, SIGSEGV, buf, buflen);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1960
  print_signal_handler(st, SIGBUS , buf, buflen);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1961
  print_signal_handler(st, SIGFPE , buf, buflen);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1962
  print_signal_handler(st, SIGPIPE, buf, buflen);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1963
  print_signal_handler(st, SIGXFSZ, buf, buflen);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1964
  print_signal_handler(st, SIGILL , buf, buflen);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1965
  print_signal_handler(st, INTERRUPT_SIGNAL, buf, buflen);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1966
  print_signal_handler(st, SR_signum, buf, buflen);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1967
  print_signal_handler(st, SHUTDOWN1_SIGNAL, buf, buflen);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1968
  print_signal_handler(st, SHUTDOWN2_SIGNAL , buf, buflen);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1969
  print_signal_handler(st, SHUTDOWN3_SIGNAL , buf, buflen);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1970
  print_signal_handler(st, BREAK_SIGNAL, buf, buflen);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1971
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1972
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1973
static char saved_jvm_path[MAXPATHLEN] = {0};
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1974
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1975
// Find the full path to the current module, libjvm.so or libjvm_g.so
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1976
void os::jvm_path(char *buf, jint len) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1977
  // Error checking.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1978
  if (len < MAXPATHLEN) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1979
    assert(false, "must use a large-enough buffer");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1980
    buf[0] = '\0';
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1981
    return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1982
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1983
  // Lazy resolve the path to current module.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1984
  if (saved_jvm_path[0] != 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1985
    strcpy(buf, saved_jvm_path);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1986
    return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1987
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1988
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1989
  char dli_fname[MAXPATHLEN];
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1990
  bool ret = dll_address_to_library_name(
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1991
                CAST_FROM_FN_PTR(address, os::jvm_path),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1992
                dli_fname, sizeof(dli_fname), NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1993
  assert(ret != 0, "cannot locate libjvm");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1994
  realpath(dli_fname, buf);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1995
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1996
  if (strcmp(Arguments::sun_java_launcher(), "gamma") == 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1997
    // Support for the gamma launcher.  Typical value for buf is
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1998
    // "<JAVA_HOME>/jre/lib/<arch>/<vmtype>/libjvm.so".  If "/jre/lib/" appears at
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1999
    // the right place in the string, then assume we are installed in a JDK and
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2000
    // we're done.  Otherwise, check for a JAVA_HOME environment variable and fix
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2001
    // up the path so it looks like libjvm.so is installed there (append a
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2002
    // fake suffix hotspot/libjvm.so).
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2003
    const char *p = buf + strlen(buf) - 1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2004
    for (int count = 0; p > buf && count < 5; ++count) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2005
      for (--p; p > buf && *p != '/'; --p)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2006
        /* empty */ ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2007
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2008
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2009
    if (strncmp(p, "/jre/lib/", 9) != 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2010
      // Look for JAVA_HOME in the environment.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2011
      char* java_home_var = ::getenv("JAVA_HOME");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2012
      if (java_home_var != NULL && java_home_var[0] != 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2013
        // Check the current module name "libjvm.so" or "libjvm_g.so".
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2014
        p = strrchr(buf, '/');
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2015
        assert(strstr(p, "/libjvm") == p, "invalid library name");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2016
        p = strstr(p, "_g") ? "_g" : "";
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2017
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2018
        realpath(java_home_var, buf);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2019
        sprintf(buf + strlen(buf), "/jre/lib/%s", cpu_arch);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2020
        if (0 == access(buf, F_OK)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2021
          // Use current module name "libjvm[_g].so" instead of
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2022
          // "libjvm"debug_only("_g")".so" since for fastdebug version
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2023
          // we should have "libjvm.so" but debug_only("_g") adds "_g"!
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2024
          // It is used when we are choosing the HPI library's name
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2025
          // "libhpi[_g].so" in hpi::initialize_get_interface().
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2026
          sprintf(buf + strlen(buf), "/hotspot/libjvm%s.so", p);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2027
        } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2028
          // Go back to path of .so
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2029
          realpath(dli_fname, 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
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2033
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2034
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2035
  strcpy(saved_jvm_path, buf);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2036
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2037
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2038
void os::print_jni_name_prefix_on(outputStream* st, int args_size) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2039
  // no prefix required, not even "_"
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2040
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2041
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2042
void os::print_jni_name_suffix_on(outputStream* st, int args_size) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2043
  // no suffix required
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2044
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2045
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2046
////////////////////////////////////////////////////////////////////////////////
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2047
// sun.misc.Signal support
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2048
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2049
static volatile jint sigint_count = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2050
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2051
static void
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2052
UserHandler(int sig, void *siginfo, void *context) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2053
  // 4511530 - sem_post is serialized and handled by the manager thread. When
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2054
  // the program is interrupted by Ctrl-C, SIGINT is sent to every thread. We
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2055
  // don't want to flood the manager thread with sem_post requests.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2056
  if (sig == SIGINT && Atomic::add(1, &sigint_count) > 1)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2057
      return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2058
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2059
  // Ctrl-C is pressed during error reporting, likely because the error
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2060
  // handler fails to abort. Let VM die immediately.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2061
  if (sig == SIGINT && is_error_reported()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2062
     os::die();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2063
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2064
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2065
  os::signal_notify(sig);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2066
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2067
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2068
void* os::user_handler() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2069
  return CAST_FROM_FN_PTR(void*, UserHandler);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2070
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2071
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2072
extern "C" {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2073
  typedef void (*sa_handler_t)(int);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2074
  typedef void (*sa_sigaction_t)(int, siginfo_t *, void *);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2075
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2076
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2077
void* os::signal(int signal_number, void* handler) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2078
  struct sigaction sigAct, oldSigAct;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2079
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2080
  sigfillset(&(sigAct.sa_mask));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2081
  sigAct.sa_flags   = SA_RESTART|SA_SIGINFO;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2082
  sigAct.sa_handler = CAST_TO_FN_PTR(sa_handler_t, handler);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2083
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2084
  if (sigaction(signal_number, &sigAct, &oldSigAct)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2085
    // -1 means registration failed
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2086
    return (void *)-1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2087
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2088
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2089
  return CAST_FROM_FN_PTR(void*, oldSigAct.sa_handler);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2090
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2091
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2092
void os::signal_raise(int signal_number) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2093
  ::raise(signal_number);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2094
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2095
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2096
/*
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2097
 * The following code is moved from os.cpp for making this
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2098
 * code platform specific, which it is by its very nature.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2099
 */
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2100
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2101
// Will be modified when max signal is changed to be dynamic
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2102
int os::sigexitnum_pd() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2103
  return NSIG;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2104
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2105
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2106
// a counter for each possible signal value
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2107
static volatile jint pending_signals[NSIG+1] = { 0 };
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2108
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2109
// Linux(POSIX) specific hand shaking semaphore.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2110
static sem_t sig_sem;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2111
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2112
void os::signal_init_pd() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2113
  // Initialize signal structures
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2114
  ::memset((void*)pending_signals, 0, sizeof(pending_signals));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2115
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2116
  // Initialize signal semaphore
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2117
  ::sem_init(&sig_sem, 0, 0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2118
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2119
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2120
void os::signal_notify(int sig) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2121
  Atomic::inc(&pending_signals[sig]);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2122
  ::sem_post(&sig_sem);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2123
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2124
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2125
static int check_pending_signals(bool wait) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2126
  Atomic::store(0, &sigint_count);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2127
  for (;;) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2128
    for (int i = 0; i < NSIG + 1; i++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2129
      jint n = pending_signals[i];
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2130
      if (n > 0 && n == Atomic::cmpxchg(n - 1, &pending_signals[i], n)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2131
        return i;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2132
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2133
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2134
    if (!wait) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2135
      return -1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2136
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2137
    JavaThread *thread = JavaThread::current();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2138
    ThreadBlockInVM tbivm(thread);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2139
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2140
    bool threadIsSuspended;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2141
    do {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2142
      thread->set_suspend_equivalent();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2143
      // cleared by handle_special_suspend_equivalent_condition() or java_suspend_self()
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2144
      ::sem_wait(&sig_sem);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2145
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2146
      // were we externally suspended while we were waiting?
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2147
      threadIsSuspended = thread->handle_special_suspend_equivalent_condition();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2148
      if (threadIsSuspended) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2149
        //
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2150
        // The semaphore has been incremented, but while we were waiting
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2151
        // another thread suspended us. We don't want to continue running
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2152
        // while suspended because that would surprise the thread that
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2153
        // suspended us.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2154
        //
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2155
        ::sem_post(&sig_sem);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2156
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2157
        thread->java_suspend_self();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2158
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2159
    } while (threadIsSuspended);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2160
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2161
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2162
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2163
int os::signal_lookup() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2164
  return check_pending_signals(false);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2165
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2166
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2167
int os::signal_wait() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2168
  return check_pending_signals(true);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2169
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2170
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2171
////////////////////////////////////////////////////////////////////////////////
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2172
// Virtual Memory
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2173
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2174
int os::vm_page_size() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2175
  // Seems redundant as all get out
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
// Solaris allocates memory by pages.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2181
int os::vm_allocation_granularity() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2182
  assert(os::Linux::page_size() != -1, "must call os::init");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2183
  return os::Linux::page_size();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2184
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2185
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2186
// Rationale behind this function:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2187
//  current (Mon Apr 25 20:12:18 MSD 2005) oprofile drops samples without executable
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2188
//  mapping for address (see lookup_dcookie() in the kernel module), thus we cannot get
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2189
//  samples for JITted code. Here we create private executable mapping over the code cache
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2190
//  and then we can use standard (well, almost, as mapping can change) way to provide
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2191
//  info for the reporting script by storing timestamp and location of symbol
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2192
void linux_wrap_code(char* base, size_t size) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2193
  static volatile jint cnt = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2194
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2195
  if (!UseOprofile) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2196
    return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2197
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2198
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2199
  char buf[40];
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2200
  int num = Atomic::add(1, &cnt);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2201
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2202
  sprintf(buf, "/tmp/hs-vm-%d-%d", os::current_process_id(), num);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2203
  unlink(buf);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2204
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2205
  int fd = open(buf, O_CREAT | O_RDWR, S_IRWXU);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2206
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2207
  if (fd != -1) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2208
    off_t rv = lseek(fd, size-2, SEEK_SET);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2209
    if (rv != (off_t)-1) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2210
      if (write(fd, "", 1) == 1) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2211
        mmap(base, size,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2212
             PROT_READ|PROT_WRITE|PROT_EXEC,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2213
             MAP_PRIVATE|MAP_FIXED|MAP_NORESERVE, fd, 0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2214
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2215
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2216
    close(fd);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2217
    unlink(buf);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2218
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2219
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2220
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2221
// NOTE: Linux kernel does not really reserve the pages for us.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2222
//       All it does is to check if there are enough free pages
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2223
//       left at the time of mmap(). This could be a potential
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2224
//       problem.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2225
bool os::commit_memory(char* addr, size_t size) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2226
  uintptr_t res = (uintptr_t) ::mmap(addr, size,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2227
                                   PROT_READ|PROT_WRITE|PROT_EXEC,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2228
                                   MAP_PRIVATE|MAP_FIXED|MAP_ANONYMOUS, -1, 0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2229
  return res != (uintptr_t) MAP_FAILED;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2230
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2231
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2232
bool os::commit_memory(char* addr, size_t size, size_t alignment_hint) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2233
  return commit_memory(addr, size);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2234
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2235
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2236
void os::realign_memory(char *addr, size_t bytes, size_t alignment_hint) { }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2237
void os::free_memory(char *addr, size_t bytes)         { }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2238
void os::numa_make_global(char *addr, size_t bytes)    { }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2239
void os::numa_make_local(char *addr, size_t bytes)     { }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2240
bool os::numa_topology_changed()                       { return false; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2241
size_t os::numa_get_groups_num()                       { return 1; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2242
int os::numa_get_group_id()                            { return 0; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2243
size_t os::numa_get_leaf_groups(int *ids, size_t size) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2244
  if (size > 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2245
    ids[0] = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2246
    return 1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2247
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2248
  return 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2249
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2250
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2251
bool os::get_page_info(char *start, page_info* info) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2252
  return false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2253
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2254
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2255
char *os::scan_pages(char *start, char* end, page_info* page_expected, page_info* page_found) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2256
  return end;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2257
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2258
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2259
bool os::uncommit_memory(char* addr, size_t size) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2260
  return ::mmap(addr, size,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2261
                PROT_READ|PROT_WRITE|PROT_EXEC,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2262
                MAP_PRIVATE|MAP_FIXED|MAP_NORESERVE|MAP_ANONYMOUS, -1, 0)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2263
    != MAP_FAILED;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2264
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2265
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2266
static address _highest_vm_reserved_address = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2267
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2268
// If 'fixed' is true, anon_mmap() will attempt to reserve anonymous memory
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2269
// at 'requested_addr'. If there are existing memory mappings at the same
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2270
// location, however, they will be overwritten. If 'fixed' is false,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2271
// 'requested_addr' is only treated as a hint, the return value may or
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2272
// may not start from the requested address. Unlike Linux mmap(), this
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2273
// function returns NULL to indicate failure.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2274
static char* anon_mmap(char* requested_addr, size_t bytes, bool fixed) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2275
  char * addr;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2276
  int flags;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2277
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2278
  flags = MAP_PRIVATE | MAP_NORESERVE | MAP_ANONYMOUS;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2279
  if (fixed) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2280
    assert((uintptr_t)requested_addr % os::Linux::page_size() == 0, "unaligned address");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2281
    flags |= MAP_FIXED;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2282
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2283
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2284
  addr = (char*)::mmap(requested_addr, bytes, PROT_READ|PROT_WRITE|PROT_EXEC,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2285
                       flags, -1, 0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2286
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2287
  if (addr != MAP_FAILED) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2288
    // anon_mmap() should only get called during VM initialization,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2289
    // don't need lock (actually we can skip locking even it can be called
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2290
    // from multiple threads, because _highest_vm_reserved_address is just a
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2291
    // hint about the upper limit of non-stack memory regions.)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2292
    if ((address)addr + bytes > _highest_vm_reserved_address) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2293
      _highest_vm_reserved_address = (address)addr + bytes;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2294
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2295
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2296
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2297
  return addr == MAP_FAILED ? NULL : addr;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2298
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2299
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2300
// Don't update _highest_vm_reserved_address, because there might be memory
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2301
// regions above addr + size. If so, releasing a memory region only creates
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2302
// a hole in the address space, it doesn't help prevent heap-stack collision.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2303
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2304
static int anon_munmap(char * addr, size_t size) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2305
  return ::munmap(addr, size) == 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2306
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2307
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2308
char* os::reserve_memory(size_t bytes, char* requested_addr,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2309
                         size_t alignment_hint) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2310
  return anon_mmap(requested_addr, bytes, (requested_addr != NULL));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2311
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2312
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2313
bool os::release_memory(char* addr, size_t size) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2314
  return anon_munmap(addr, size);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2315
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2316
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2317
static address highest_vm_reserved_address() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2318
  return _highest_vm_reserved_address;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2319
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2320
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2321
static bool linux_mprotect(char* addr, size_t size, int prot) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2322
  // Linux wants the mprotect address argument to be page aligned.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2323
  char* bottom = (char*)align_size_down((intptr_t)addr, os::Linux::page_size());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2324
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2325
  // According to SUSv3, mprotect() should only be used with mappings
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2326
  // established by mmap(), and mmap() always maps whole pages. Unaligned
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2327
  // 'addr' likely indicates problem in the VM (e.g. trying to change
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2328
  // protection of malloc'ed or statically allocated memory). Check the
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2329
  // caller if you hit this assert.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2330
  assert(addr == bottom, "sanity check");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2331
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2332
  size = align_size_up(pointer_delta(addr, bottom, 1) + size, os::Linux::page_size());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2333
  return ::mprotect(bottom, size, prot) == 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2334
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2335
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2336
bool os::protect_memory(char* addr, size_t size) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2337
  return linux_mprotect(addr, size, PROT_READ);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2338
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2339
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2340
bool os::guard_memory(char* addr, size_t size) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2341
  return linux_mprotect(addr, size, PROT_NONE);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2342
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2343
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2344
bool os::unguard_memory(char* addr, size_t size) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2345
  return linux_mprotect(addr, size, PROT_READ|PROT_WRITE|PROT_EXEC);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2346
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2347
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2348
// Large page support
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2349
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2350
static size_t _large_page_size = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2351
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2352
bool os::large_page_init() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2353
  if (!UseLargePages) return false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2354
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2355
  if (LargePageSizeInBytes) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2356
    _large_page_size = LargePageSizeInBytes;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2357
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2358
    // large_page_size on Linux is used to round up heap size. x86 uses either
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2359
    // 2M or 4M page, depending on whether PAE (Physical Address Extensions)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2360
    // mode is enabled. AMD64/EM64T uses 2M page in 64bit mode. IA64 can use
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2361
    // page as large as 256M.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2362
    //
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2363
    // Here we try to figure out page size by parsing /proc/meminfo and looking
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2364
    // for a line with the following format:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2365
    //    Hugepagesize:     2048 kB
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2366
    //
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2367
    // If we can't determine the value (e.g. /proc is not mounted, or the text
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2368
    // format has been changed), we'll use the largest page size supported by
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2369
    // the processor.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2370
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2371
    _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
  2372
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2373
    FILE *fp = fopen("/proc/meminfo", "r");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2374
    if (fp) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2375
      while (!feof(fp)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2376
        int x = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2377
        char buf[16];
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2378
        if (fscanf(fp, "Hugepagesize: %d", &x) == 1) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2379
          if (x && fgets(buf, sizeof(buf), fp) && strcmp(buf, " kB\n") == 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2380
            _large_page_size = x * K;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2381
            break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2382
          }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2383
        } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2384
          // skip to next line
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2385
          for (;;) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2386
            int ch = fgetc(fp);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2387
            if (ch == EOF || ch == (int)'\n') break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2388
          }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2389
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2390
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2391
      fclose(fp);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2392
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2393
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2394
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2395
  const size_t default_page_size = (size_t)Linux::page_size();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2396
  if (_large_page_size > default_page_size) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2397
    _page_sizes[0] = _large_page_size;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2398
    _page_sizes[1] = default_page_size;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2399
    _page_sizes[2] = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2400
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2401
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2402
  // Large page support is available on 2.6 or newer kernel, some vendors
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2403
  // (e.g. Redhat) have backported it to their 2.4 based distributions.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2404
  // We optimistically assume the support is available. If later it turns out
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2405
  // not true, VM will automatically switch to use regular page size.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2406
  return true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2407
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2408
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2409
#ifndef SHM_HUGETLB
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2410
#define SHM_HUGETLB 04000
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2411
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2412
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2413
char* os::reserve_memory_special(size_t bytes) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2414
  assert(UseLargePages, "only for large pages");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2415
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2416
  key_t key = IPC_PRIVATE;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2417
  char *addr;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2418
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2419
  bool warn_on_failure = UseLargePages &&
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2420
                        (!FLAG_IS_DEFAULT(UseLargePages) ||
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2421
                         !FLAG_IS_DEFAULT(LargePageSizeInBytes)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2422
                        );
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2423
  char msg[128];
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2424
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2425
  // Create a large shared memory region to attach to based on size.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2426
  // Currently, size is the total size of the heap
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2427
  int shmid = shmget(key, bytes, SHM_HUGETLB|IPC_CREAT|SHM_R|SHM_W);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2428
  if (shmid == -1) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2429
     // Possible reasons for shmget failure:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2430
     // 1. shmmax is too small for Java heap.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2431
     //    > check shmmax value: cat /proc/sys/kernel/shmmax
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2432
     //    > increase shmmax value: echo "0xffffffff" > /proc/sys/kernel/shmmax
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2433
     // 2. not enough large page memory.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2434
     //    > check available large pages: cat /proc/meminfo
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2435
     //    > increase amount of large pages:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2436
     //          echo new_value > /proc/sys/vm/nr_hugepages
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2437
     //      Note 1: different Linux may use different name for this property,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2438
     //            e.g. on Redhat AS-3 it is "hugetlb_pool".
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2439
     //      Note 2: it's possible there's enough physical memory available but
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2440
     //            they are so fragmented after a long run that they can't
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2441
     //            coalesce into large pages. Try to reserve large pages when
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2442
     //            the system is still "fresh".
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2443
     if (warn_on_failure) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2444
       jio_snprintf(msg, sizeof(msg), "Failed to reserve shared memory (errno = %d).", errno);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2445
       warning(msg);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2446
     }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2447
     return NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2448
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2449
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2450
  // attach to the region
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2451
  addr = (char*)shmat(shmid, NULL, 0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2452
  int err = errno;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2453
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2454
  // Remove shmid. If shmat() is successful, the actual shared memory segment
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2455
  // will be deleted when it's detached by shmdt() or when the process
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2456
  // terminates. If shmat() is not successful this will remove the shared
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2457
  // segment immediately.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2458
  shmctl(shmid, IPC_RMID, NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2459
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2460
  if ((intptr_t)addr == -1) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2461
     if (warn_on_failure) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2462
       jio_snprintf(msg, sizeof(msg), "Failed to attach shared memory (errno = %d).", err);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2463
       warning(msg);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2464
     }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2465
     return NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2466
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2467
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2468
  return addr;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2469
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2470
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2471
bool os::release_memory_special(char* base, size_t bytes) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2472
  // detaching the SHM segment will also delete it, see reserve_memory_special()
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2473
  int rslt = shmdt(base);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2474
  return rslt == 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2475
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2476
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2477
size_t os::large_page_size() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2478
  return _large_page_size;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2479
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2480
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2481
// Linux does not support anonymous mmap with large page memory. The only way
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2482
// to reserve large page memory without file backing is through SysV shared
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2483
// memory API. The entire memory region is committed and pinned upfront.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2484
// Hopefully this will change in the future...
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2485
bool os::can_commit_large_page_memory() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2486
  return false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2487
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2488
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2489
// Reserve memory at an arbitrary address, only if that area is
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2490
// available (and not reserved for something else).
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2491
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2492
char* os::attempt_reserve_memory_at(size_t bytes, char* requested_addr) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2493
  const int max_tries = 10;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2494
  char* base[max_tries];
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2495
  size_t size[max_tries];
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2496
  const size_t gap = 0x000000;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2497
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2498
  // Assert only that the size is a multiple of the page size, since
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2499
  // that's all that mmap requires, and since that's all we really know
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2500
  // about at this low abstraction level.  If we need higher alignment,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2501
  // we can either pass an alignment to this method or verify alignment
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2502
  // in one of the methods further up the call chain.  See bug 5044738.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2503
  assert(bytes % os::vm_page_size() == 0, "reserving unexpected size block");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2504
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2505
  // Repeatedly allocate blocks until the block is allocated at the
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2506
  // right spot. Give up after max_tries. Note that reserve_memory() will
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2507
  // automatically update _highest_vm_reserved_address if the call is
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2508
  // successful. The variable tracks the highest memory address every reserved
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2509
  // by JVM. It is used to detect heap-stack collision if running with
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2510
  // fixed-stack LinuxThreads. Because here we may attempt to reserve more
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2511
  // space than needed, it could confuse the collision detecting code. To
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2512
  // solve the problem, save current _highest_vm_reserved_address and
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2513
  // calculate the correct value before return.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2514
  address old_highest = _highest_vm_reserved_address;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2515
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2516
  // Linux mmap allows caller to pass an address as hint; give it a try first,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2517
  // if kernel honors the hint then we can return immediately.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2518
  char * addr = anon_mmap(requested_addr, bytes, false);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2519
  if (addr == requested_addr) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2520
     return requested_addr;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2521
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2522
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2523
  if (addr != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2524
     // mmap() is successful but it fails to reserve at the requested address
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2525
     anon_munmap(addr, bytes);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2526
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2527
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2528
  int i;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2529
  for (i = 0; i < max_tries; ++i) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2530
    base[i] = reserve_memory(bytes);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2531
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2532
    if (base[i] != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2533
      // Is this the block we wanted?
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2534
      if (base[i] == requested_addr) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2535
        size[i] = bytes;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2536
        break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2537
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2538
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2539
      // Does this overlap the block we wanted? Give back the overlapped
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2540
      // parts and try again.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2541
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2542
      size_t top_overlap = requested_addr + (bytes + gap) - base[i];
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2543
      if (top_overlap >= 0 && top_overlap < bytes) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2544
        unmap_memory(base[i], top_overlap);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2545
        base[i] += top_overlap;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2546
        size[i] = bytes - top_overlap;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2547
      } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2548
        size_t bottom_overlap = base[i] + bytes - requested_addr;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2549
        if (bottom_overlap >= 0 && bottom_overlap < bytes) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2550
          unmap_memory(requested_addr, bottom_overlap);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2551
          size[i] = bytes - bottom_overlap;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2552
        } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2553
          size[i] = bytes;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2554
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2555
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2556
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2557
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2558
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2559
  // Give back the unused reserved pieces.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2560
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2561
  for (int j = 0; j < i; ++j) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2562
    if (base[j] != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2563
      unmap_memory(base[j], size[j]);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2564
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2565
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2566
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2567
  if (i < max_tries) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2568
    _highest_vm_reserved_address = MAX2(old_highest, (address)requested_addr + bytes);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2569
    return requested_addr;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2570
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2571
    _highest_vm_reserved_address = old_highest;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2572
    return NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2573
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2574
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2575
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2576
size_t os::read(int fd, void *buf, unsigned int nBytes) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2577
  return ::read(fd, buf, nBytes);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2578
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2579
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2580
// TODO-FIXME: reconcile Solaris' os::sleep with the linux variation.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2581
// Solaris uses poll(), linux uses park().
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2582
// Poll() is likely a better choice, assuming that Thread.interrupt()
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2583
// generates a SIGUSRx signal. Note that SIGUSR1 can interfere with
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2584
// SIGSEGV, see 4355769.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2585
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2586
const int NANOSECS_PER_MILLISECS = 1000000;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2587
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2588
int os::sleep(Thread* thread, jlong millis, bool interruptible) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2589
  assert(thread == Thread::current(),  "thread consistency check");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2590
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2591
  ParkEvent * const slp = thread->_SleepEvent ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2592
  slp->reset() ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2593
  OrderAccess::fence() ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2594
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2595
  if (interruptible) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2596
    jlong prevtime = javaTimeNanos();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2597
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2598
    for (;;) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2599
      if (os::is_interrupted(thread, true)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2600
        return OS_INTRPT;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2601
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2602
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2603
      jlong newtime = javaTimeNanos();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2604
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2605
      if (newtime - prevtime < 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2606
        // time moving backwards, should only happen if no monotonic clock
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2607
        // not a guarantee() because JVM should not abort on kernel/glibc bugs
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2608
        assert(!Linux::supports_monotonic_clock(), "time moving backwards");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2609
      } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2610
        millis -= (newtime - prevtime) / NANOSECS_PER_MILLISECS;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2611
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2612
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2613
      if(millis <= 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2614
        return OS_OK;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2615
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2616
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2617
      prevtime = newtime;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2618
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2619
      {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2620
        assert(thread->is_Java_thread(), "sanity check");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2621
        JavaThread *jt = (JavaThread *) thread;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2622
        ThreadBlockInVM tbivm(jt);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2623
        OSThreadWaitState osts(jt->osthread(), false /* not Object.wait() */);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2624
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2625
        jt->set_suspend_equivalent();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2626
        // cleared by handle_special_suspend_equivalent_condition() or
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2627
        // java_suspend_self() via check_and_wait_while_suspended()
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2628
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2629
        slp->park(millis);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2630
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2631
        // were we externally suspended while we were waiting?
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2632
        jt->check_and_wait_while_suspended();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2633
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2634
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2635
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2636
    OSThreadWaitState osts(thread->osthread(), false /* not Object.wait() */);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2637
    jlong prevtime = javaTimeNanos();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2638
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2639
    for (;;) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2640
      // It'd be nice to avoid the back-to-back javaTimeNanos() calls on
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2641
      // the 1st iteration ...
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2642
      jlong newtime = javaTimeNanos();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2643
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2644
      if (newtime - prevtime < 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2645
        // time moving backwards, should only happen if no monotonic clock
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2646
        // not a guarantee() because JVM should not abort on kernel/glibc bugs
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2647
        assert(!Linux::supports_monotonic_clock(), "time moving backwards");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2648
      } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2649
        millis -= (newtime - prevtime) / NANOSECS_PER_MILLISECS;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2650
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2651
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2652
      if(millis <= 0) break ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2653
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2654
      prevtime = newtime;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2655
      slp->park(millis);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2656
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2657
    return OS_OK ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2658
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2659
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2660
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2661
int os::naked_sleep() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2662
  // %% make the sleep time an integer flag. for now use 1 millisec.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2663
  return os::sleep(Thread::current(), 1, false);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2664
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2665
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2666
// Sleep forever; naked call to OS-specific sleep; use with CAUTION
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2667
void os::infinite_sleep() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2668
  while (true) {    // sleep forever ...
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2669
    ::sleep(100);   // ... 100 seconds at a time
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2670
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2671
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2672
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2673
// Used to convert frequent JVM_Yield() to nops
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2674
bool os::dont_yield() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2675
  return DontYieldALot;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2676
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2677
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2678
void os::yield() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2679
  sched_yield();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2680
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2681
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2682
os::YieldResult os::NakedYield() { sched_yield(); return os::YIELD_UNKNOWN ;}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2683
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2684
void os::yield_all(int attempts) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2685
  // Yields to all threads, including threads with lower priorities
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2686
  // Threads on Linux are all with same priority. The Solaris style
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2687
  // os::yield_all() with nanosleep(1ms) is not necessary.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2688
  sched_yield();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2689
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2690
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2691
// Called from the tight loops to possibly influence time-sharing heuristics
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2692
void os::loop_breaker(int attempts) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2693
  os::yield_all(attempts);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2694
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2695
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2696
////////////////////////////////////////////////////////////////////////////////
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2697
// thread priority support
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2698
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2699
// Note: Normal Linux applications are run with SCHED_OTHER policy. SCHED_OTHER
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2700
// only supports dynamic priority, static priority must be zero. For real-time
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2701
// applications, Linux supports SCHED_RR which allows static priority (1-99).
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2702
// However, for large multi-threaded applications, SCHED_RR is not only slower
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2703
// than SCHED_OTHER, but also very unstable (my volano tests hang hard 4 out
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2704
// of 5 runs - Sep 2005).
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2705
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2706
// The following code actually changes the niceness of kernel-thread/LWP. It
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2707
// has an assumption that setpriority() only modifies one kernel-thread/LWP,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2708
// not the entire user process, and user level threads are 1:1 mapped to kernel
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2709
// threads. It has always been the case, but could change in the future. For
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2710
// this reason, the code should not be used as default (ThreadPriorityPolicy=0).
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2711
// It is only used when ThreadPriorityPolicy=1 and requires root privilege.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2712
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2713
int os::java_to_os_priority[MaxPriority + 1] = {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2714
  19,              // 0 Entry should never be used
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2715
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2716
   4,              // 1 MinPriority
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2717
   3,              // 2
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2718
   2,              // 3
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2719
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2720
   1,              // 4
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2721
   0,              // 5 NormPriority
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2722
  -1,              // 6
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2723
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2724
  -2,              // 7
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2725
  -3,              // 8
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2726
  -4,              // 9 NearMaxPriority
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2727
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2728
  -5               // 10 MaxPriority
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2729
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2730
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2731
static int prio_init() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2732
  if (ThreadPriorityPolicy == 1) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2733
    // Only root can raise thread priority. Don't allow ThreadPriorityPolicy=1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2734
    // if effective uid is not root. Perhaps, a more elegant way of doing
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2735
    // this is to test CAP_SYS_NICE capability, but that will require libcap.so
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2736
    if (geteuid() != 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2737
      if (!FLAG_IS_DEFAULT(ThreadPriorityPolicy)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2738
        warning("-XX:ThreadPriorityPolicy requires root privilege on Linux");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2739
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2740
      ThreadPriorityPolicy = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2741
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2742
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2743
  return 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2744
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2745
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2746
OSReturn os::set_native_priority(Thread* thread, int newpri) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2747
  if ( !UseThreadPriorities || ThreadPriorityPolicy == 0 ) return OS_OK;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2748
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2749
  int ret = setpriority(PRIO_PROCESS, thread->osthread()->thread_id(), newpri);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2750
  return (ret == 0) ? OS_OK : OS_ERR;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2751
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2752
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2753
OSReturn os::get_native_priority(const Thread* const thread, int *priority_ptr) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2754
  if ( !UseThreadPriorities || ThreadPriorityPolicy == 0 ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2755
    *priority_ptr = java_to_os_priority[NormPriority];
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2756
    return OS_OK;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2757
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2758
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2759
  errno = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2760
  *priority_ptr = getpriority(PRIO_PROCESS, thread->osthread()->thread_id());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2761
  return (*priority_ptr != -1 || errno == 0 ? OS_OK : OS_ERR);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2762
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2763
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2764
// Hint to the underlying OS that a task switch would not be good.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2765
// Void return because it's a hint and can fail.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2766
void os::hint_no_preempt() {}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2767
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2768
////////////////////////////////////////////////////////////////////////////////
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2769
// suspend/resume support
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2770
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2771
//  the low-level signal-based suspend/resume support is a remnant from the
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2772
//  old VM-suspension that used to be for java-suspension, safepoints etc,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2773
//  within hotspot. Now there is a single use-case for this:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2774
//    - calling get_thread_pc() on the VMThread by the flat-profiler task
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2775
//      that runs in the watcher thread.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2776
//  The remaining code is greatly simplified from the more general suspension
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2777
//  code that used to be used.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2778
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2779
//  The protocol is quite simple:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2780
//  - suspend:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2781
//      - sends a signal to the target thread
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2782
//      - polls the suspend state of the osthread using a yield loop
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2783
//      - target thread signal handler (SR_handler) sets suspend state
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2784
//        and blocks in sigsuspend until continued
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2785
//  - resume:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2786
//      - sets target osthread state to continue
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2787
//      - sends signal to end the sigsuspend loop in the SR_handler
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2788
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2789
//  Note that the SR_lock plays no role in this suspend/resume protocol.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2790
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2791
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2792
static void resume_clear_context(OSThread *osthread) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2793
  osthread->set_ucontext(NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2794
  osthread->set_siginfo(NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2795
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2796
  // notify the suspend action is completed, we have now resumed
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2797
  osthread->sr.clear_suspended();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2798
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2799
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2800
static void suspend_save_context(OSThread *osthread, siginfo_t* siginfo, ucontext_t* context) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2801
  osthread->set_ucontext(context);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2802
  osthread->set_siginfo(siginfo);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2803
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2804
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2805
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2806
// Handler function invoked when a thread's execution is suspended or
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2807
// resumed. We have to be careful that only async-safe functions are
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2808
// called here (Note: most pthread functions are not async safe and
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2809
// should be avoided.)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2810
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2811
// Note: sigwait() is a more natural fit than sigsuspend() from an
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2812
// interface point of view, but sigwait() prevents the signal hander
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2813
// from being run. libpthread would get very confused by not having
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2814
// its signal handlers run and prevents sigwait()'s use with the
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2815
// mutex granting granting signal.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2816
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2817
// Currently only ever called on the VMThread
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2818
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2819
static void SR_handler(int sig, siginfo_t* siginfo, ucontext_t* context) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2820
  // Save and restore errno to avoid confusing native code with EINTR
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2821
  // after sigsuspend.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2822
  int old_errno = errno;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2823
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2824
  Thread* thread = Thread::current();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2825
  OSThread* osthread = thread->osthread();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2826
  assert(thread->is_VM_thread(), "Must be VMThread");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2827
  // read current suspend action
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2828
  int action = osthread->sr.suspend_action();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2829
  if (action == SR_SUSPEND) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2830
    suspend_save_context(osthread, siginfo, context);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2831
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2832
    // Notify the suspend action is about to be completed. do_suspend()
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2833
    // waits until SR_SUSPENDED is set and then returns. We will wait
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2834
    // here for a resume signal and that completes the suspend-other
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2835
    // action. do_suspend/do_resume is always called as a pair from
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2836
    // the same thread - so there are no races
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2837
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2838
    // notify the caller
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2839
    osthread->sr.set_suspended();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2840
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2841
    sigset_t suspend_set;  // signals for sigsuspend()
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2842
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2843
    // get current set of blocked signals and unblock resume signal
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2844
    pthread_sigmask(SIG_BLOCK, NULL, &suspend_set);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2845
    sigdelset(&suspend_set, SR_signum);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2846
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2847
    // wait here until we are resumed
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2848
    do {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2849
      sigsuspend(&suspend_set);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2850
      // ignore all returns until we get a resume signal
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2851
    } while (osthread->sr.suspend_action() != SR_CONTINUE);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2852
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2853
    resume_clear_context(osthread);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2854
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2855
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2856
    assert(action == SR_CONTINUE, "unexpected sr action");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2857
    // nothing special to do - just leave the handler
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2858
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2859
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2860
  errno = old_errno;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2861
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2862
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2863
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2864
static int SR_initialize() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2865
  struct sigaction act;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2866
  char *s;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2867
  /* Get signal number to use for suspend/resume */
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2868
  if ((s = ::getenv("_JAVA_SR_SIGNUM")) != 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2869
    int sig = ::strtol(s, 0, 10);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2870
    if (sig > 0 || sig < _NSIG) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2871
        SR_signum = sig;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2872
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2873
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2874
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2875
  assert(SR_signum > SIGSEGV && SR_signum > SIGBUS,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2876
        "SR_signum must be greater than max(SIGSEGV, SIGBUS), see 4355769");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2877
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2878
  sigemptyset(&SR_sigset);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2879
  sigaddset(&SR_sigset, SR_signum);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2880
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2881
  /* Set up signal handler for suspend/resume */
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2882
  act.sa_flags = SA_RESTART|SA_SIGINFO;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2883
  act.sa_handler = (void (*)(int)) SR_handler;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2884
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2885
  // SR_signum is blocked by default.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2886
  // 4528190 - We also need to block pthread restart signal (32 on all
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2887
  // supported Linux platforms). Note that LinuxThreads need to block
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2888
  // this signal for all threads to work properly. So we don't have
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2889
  // to use hard-coded signal number when setting up the mask.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2890
  pthread_sigmask(SIG_BLOCK, NULL, &act.sa_mask);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2891
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2892
  if (sigaction(SR_signum, &act, 0) == -1) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2893
    return -1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2894
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2895
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2896
  // Save signal flag
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2897
  os::Linux::set_our_sigflags(SR_signum, act.sa_flags);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2898
  return 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2899
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2900
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2901
static int SR_finalize() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2902
  return 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2903
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2904
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2905
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2906
// returns true on success and false on error - really an error is fatal
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2907
// but this seems the normal response to library errors
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2908
static bool do_suspend(OSThread* osthread) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2909
  // mark as suspended and send signal
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2910
  osthread->sr.set_suspend_action(SR_SUSPEND);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2911
  int status = pthread_kill(osthread->pthread_id(), SR_signum);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2912
  assert_status(status == 0, status, "pthread_kill");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2913
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2914
  // check status and wait until notified of suspension
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2915
  if (status == 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2916
    for (int i = 0; !osthread->sr.is_suspended(); i++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2917
      os::yield_all(i);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2918
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2919
    osthread->sr.set_suspend_action(SR_NONE);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2920
    return true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2921
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2922
  else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2923
    osthread->sr.set_suspend_action(SR_NONE);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2924
    return false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2925
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2926
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2927
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2928
static void do_resume(OSThread* osthread) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2929
  assert(osthread->sr.is_suspended(), "thread should be suspended");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2930
  osthread->sr.set_suspend_action(SR_CONTINUE);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2931
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2932
  int status = pthread_kill(osthread->pthread_id(), SR_signum);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2933
  assert_status(status == 0, status, "pthread_kill");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2934
  // check status and wait unit notified of resumption
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2935
  if (status == 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2936
    for (int i = 0; osthread->sr.is_suspended(); i++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2937
      os::yield_all(i);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2938
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2939
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2940
  osthread->sr.set_suspend_action(SR_NONE);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2941
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2942
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2943
////////////////////////////////////////////////////////////////////////////////
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2944
// interrupt support
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2945
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2946
void os::interrupt(Thread* thread) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2947
  assert(Thread::current() == thread || Threads_lock->owned_by_self(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2948
    "possibility of dangling Thread pointer");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2949
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2950
  OSThread* osthread = thread->osthread();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2951
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2952
  if (!osthread->interrupted()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2953
    osthread->set_interrupted(true);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2954
    // More than one thread can get here with the same value of osthread,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2955
    // resulting in multiple notifications.  We do, however, want the store
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2956
    // to interrupted() to be visible to other threads before we execute unpark().
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2957
    OrderAccess::fence();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2958
    ParkEvent * const slp = thread->_SleepEvent ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2959
    if (slp != NULL) slp->unpark() ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2960
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2961
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2962
  // For JSR166. Unpark even if interrupt status already was set
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2963
  if (thread->is_Java_thread())
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2964
    ((JavaThread*)thread)->parker()->unpark();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2965
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2966
  ParkEvent * ev = thread->_ParkEvent ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2967
  if (ev != NULL) ev->unpark() ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2968
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2969
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2970
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2971
bool os::is_interrupted(Thread* thread, bool clear_interrupted) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2972
  assert(Thread::current() == thread || Threads_lock->owned_by_self(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2973
    "possibility of dangling Thread pointer");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2974
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2975
  OSThread* osthread = thread->osthread();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2976
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2977
  bool interrupted = osthread->interrupted();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2978
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2979
  if (interrupted && clear_interrupted) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2980
    osthread->set_interrupted(false);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2981
    // consider thread->_SleepEvent->reset() ... optional optimization
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2982
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2983
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2984
  return interrupted;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2985
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2986
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2987
///////////////////////////////////////////////////////////////////////////////////
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2988
// signal handling (except suspend/resume)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2989
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2990
// This routine may be used by user applications as a "hook" to catch signals.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2991
// The user-defined signal handler must pass unrecognized signals to this
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2992
// routine, and if it returns true (non-zero), then the signal handler must
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2993
// return immediately.  If the flag "abort_if_unrecognized" is true, then this
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2994
// routine will never retun false (zero), but instead will execute a VM panic
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2995
// routine kill the process.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2996
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2997
// If this routine returns false, it is OK to call it again.  This allows
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2998
// the user-defined signal handler to perform checks either before or after
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2999
// the VM performs its own checks.  Naturally, the user code would be making
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3000
// a serious error if it tried to handle an exception (such as a null check
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3001
// or breakpoint) that the VM was generating for its own correct operation.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3002
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3003
// This routine may recognize any of the following kinds of signals:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3004
//    SIGBUS, SIGSEGV, SIGILL, SIGFPE, SIGQUIT, SIGPIPE, SIGXFSZ, SIGUSR1.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3005
// It should be consulted by handlers for any of those signals.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3006
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3007
// The caller of this routine must pass in the three arguments supplied
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3008
// to the function referred to in the "sa_sigaction" (not the "sa_handler")
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3009
// field of the structure passed to sigaction().  This routine assumes that
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3010
// the sa_flags field passed to sigaction() includes SA_SIGINFO and SA_RESTART.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3011
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3012
// Note that the VM will print warnings if it detects conflicting signal
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3013
// handlers, unless invoked with the option "-XX:+AllowUserSignalHandlers".
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3014
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3015
extern "C" int
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3016
JVM_handle_linux_signal(int signo, siginfo_t* siginfo,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3017
                        void* ucontext, int abort_if_unrecognized);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3018
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3019
void signalHandler(int sig, siginfo_t* info, void* uc) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3020
  assert(info != NULL && uc != NULL, "it must be old kernel");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3021
  JVM_handle_linux_signal(sig, info, uc, true);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3022
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3023
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3024
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3025
// This boolean allows users to forward their own non-matching signals
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3026
// to JVM_handle_linux_signal, harmlessly.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3027
bool os::Linux::signal_handlers_are_installed = false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3028
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3029
// For signal-chaining
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3030
struct sigaction os::Linux::sigact[MAXSIGNUM];
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3031
unsigned int os::Linux::sigs = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3032
bool os::Linux::libjsig_is_loaded = false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3033
typedef struct sigaction *(*get_signal_t)(int);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3034
get_signal_t os::Linux::get_signal_action = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3035
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3036
struct sigaction* os::Linux::get_chained_signal_action(int sig) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3037
  struct sigaction *actp = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3038
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3039
  if (libjsig_is_loaded) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3040
    // Retrieve the old signal handler from libjsig
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3041
    actp = (*get_signal_action)(sig);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3042
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3043
  if (actp == NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3044
    // Retrieve the preinstalled signal handler from jvm
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3045
    actp = get_preinstalled_handler(sig);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3046
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3047
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3048
  return actp;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3049
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3050
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3051
static bool call_chained_handler(struct sigaction *actp, int sig,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3052
                                 siginfo_t *siginfo, void *context) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3053
  // Call the old signal handler
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3054
  if (actp->sa_handler == SIG_DFL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3055
    // It's more reasonable to let jvm treat it as an unexpected exception
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3056
    // instead of taking the default action.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3057
    return false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3058
  } else if (actp->sa_handler != SIG_IGN) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3059
    if ((actp->sa_flags & SA_NODEFER) == 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3060
      // automaticlly block the signal
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3061
      sigaddset(&(actp->sa_mask), sig);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3062
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3063
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3064
    sa_handler_t hand;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3065
    sa_sigaction_t sa;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3066
    bool siginfo_flag_set = (actp->sa_flags & SA_SIGINFO) != 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3067
    // retrieve the chained handler
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3068
    if (siginfo_flag_set) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3069
      sa = actp->sa_sigaction;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3070
    } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3071
      hand = actp->sa_handler;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3072
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3073
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3074
    if ((actp->sa_flags & SA_RESETHAND) != 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3075
      actp->sa_handler = SIG_DFL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3076
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3077
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3078
    // try to honor the signal mask
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3079
    sigset_t oset;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3080
    pthread_sigmask(SIG_SETMASK, &(actp->sa_mask), &oset);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3081
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3082
    // call into the chained handler
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3083
    if (siginfo_flag_set) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3084
      (*sa)(sig, siginfo, context);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3085
    } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3086
      (*hand)(sig);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3087
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3088
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3089
    // restore the signal mask
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3090
    pthread_sigmask(SIG_SETMASK, &oset, 0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3091
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3092
  // Tell jvm's signal handler the signal is taken care of.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3093
  return true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3094
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3095
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3096
bool os::Linux::chained_handler(int sig, siginfo_t* siginfo, void* context) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3097
  bool chained = false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3098
  // signal-chaining
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3099
  if (UseSignalChaining) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3100
    struct sigaction *actp = get_chained_signal_action(sig);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3101
    if (actp != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3102
      chained = call_chained_handler(actp, sig, siginfo, context);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3103
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3104
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3105
  return chained;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3106
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3107
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3108
struct sigaction* os::Linux::get_preinstalled_handler(int sig) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3109
  if ((( (unsigned int)1 << sig ) & sigs) != 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3110
    return &sigact[sig];
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3111
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3112
  return NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3113
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3114
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3115
void os::Linux::save_preinstalled_handler(int sig, struct sigaction& oldAct) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3116
  assert(sig > 0 && sig < MAXSIGNUM, "vm signal out of expected range");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3117
  sigact[sig] = oldAct;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3118
  sigs |= (unsigned int)1 << sig;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3119
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3120
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3121
// for diagnostic
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3122
int os::Linux::sigflags[MAXSIGNUM];
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3123
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3124
int os::Linux::get_our_sigflags(int sig) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3125
  assert(sig > 0 && sig < MAXSIGNUM, "vm signal out of expected range");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3126
  return sigflags[sig];
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3127
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3128
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3129
void os::Linux::set_our_sigflags(int sig, int flags) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3130
  assert(sig > 0 && sig < MAXSIGNUM, "vm signal out of expected range");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3131
  sigflags[sig] = flags;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3132
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3133
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3134
void os::Linux::set_signal_handler(int sig, bool set_installed) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3135
  // Check for overwrite.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3136
  struct sigaction oldAct;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3137
  sigaction(sig, (struct sigaction*)NULL, &oldAct);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3138
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3139
  void* oldhand = oldAct.sa_sigaction
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3140
                ? CAST_FROM_FN_PTR(void*,  oldAct.sa_sigaction)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3141
                : CAST_FROM_FN_PTR(void*,  oldAct.sa_handler);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3142
  if (oldhand != CAST_FROM_FN_PTR(void*, SIG_DFL) &&
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3143
      oldhand != CAST_FROM_FN_PTR(void*, SIG_IGN) &&
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3144
      oldhand != CAST_FROM_FN_PTR(void*, (sa_sigaction_t)signalHandler)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3145
    if (AllowUserSignalHandlers || !set_installed) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3146
      // Do not overwrite; user takes responsibility to forward to us.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3147
      return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3148
    } else if (UseSignalChaining) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3149
      // save the old handler in jvm
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3150
      save_preinstalled_handler(sig, oldAct);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3151
      // libjsig also interposes the sigaction() call below and saves the
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3152
      // old sigaction on it own.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3153
    } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3154
      fatal2("Encountered unexpected pre-existing sigaction handler %#lx for signal %d.", (long)oldhand, sig);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3155
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3156
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3157
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3158
  struct sigaction sigAct;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3159
  sigfillset(&(sigAct.sa_mask));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3160
  sigAct.sa_handler = SIG_DFL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3161
  if (!set_installed) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3162
    sigAct.sa_flags = SA_SIGINFO|SA_RESTART;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3163
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3164
    sigAct.sa_sigaction = signalHandler;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3165
    sigAct.sa_flags = SA_SIGINFO|SA_RESTART;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3166
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3167
  // Save flags, which are set by ours
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3168
  assert(sig > 0 && sig < MAXSIGNUM, "vm signal out of expected range");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3169
  sigflags[sig] = sigAct.sa_flags;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3170
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3171
  int ret = sigaction(sig, &sigAct, &oldAct);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3172
  assert(ret == 0, "check");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3173
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3174
  void* oldhand2  = oldAct.sa_sigaction
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3175
                  ? CAST_FROM_FN_PTR(void*, oldAct.sa_sigaction)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3176
                  : CAST_FROM_FN_PTR(void*, oldAct.sa_handler);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3177
  assert(oldhand2 == oldhand, "no concurrent signal handler installation");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3178
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3179
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3180
// install signal handlers for signals that HotSpot needs to
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3181
// handle in order to support Java-level exception handling.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3182
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3183
void os::Linux::install_signal_handlers() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3184
  if (!signal_handlers_are_installed) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3185
    signal_handlers_are_installed = true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3186
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3187
    // signal-chaining
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3188
    typedef void (*signal_setting_t)();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3189
    signal_setting_t begin_signal_setting = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3190
    signal_setting_t end_signal_setting = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3191
    begin_signal_setting = CAST_TO_FN_PTR(signal_setting_t,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3192
                             dlsym(RTLD_DEFAULT, "JVM_begin_signal_setting"));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3193
    if (begin_signal_setting != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3194
      end_signal_setting = CAST_TO_FN_PTR(signal_setting_t,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3195
                             dlsym(RTLD_DEFAULT, "JVM_end_signal_setting"));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3196
      get_signal_action = CAST_TO_FN_PTR(get_signal_t,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3197
                            dlsym(RTLD_DEFAULT, "JVM_get_signal_action"));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3198
      libjsig_is_loaded = true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3199
      assert(UseSignalChaining, "should enable signal-chaining");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3200
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3201
    if (libjsig_is_loaded) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3202
      // Tell libjsig jvm is setting signal handlers
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3203
      (*begin_signal_setting)();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3204
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3205
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3206
    set_signal_handler(SIGSEGV, true);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3207
    set_signal_handler(SIGPIPE, true);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3208
    set_signal_handler(SIGBUS, true);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3209
    set_signal_handler(SIGILL, true);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3210
    set_signal_handler(SIGFPE, true);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3211
    set_signal_handler(SIGXFSZ, true);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3212
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3213
    if (libjsig_is_loaded) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3214
      // Tell libjsig jvm finishes setting signal handlers
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3215
      (*end_signal_setting)();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3216
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3217
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3218
    // We don't activate signal checker if libjsig is in place, we trust ourselves
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3219
    // and if UserSignalHandler is installed all bets are off
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3220
    if (CheckJNICalls) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3221
      if (libjsig_is_loaded) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3222
        tty->print_cr("Info: libjsig is activated, all active signal checking is disabled");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3223
        check_signals = false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3224
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3225
      if (AllowUserSignalHandlers) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3226
        tty->print_cr("Info: AllowUserSignalHandlers is activated, all active signal checking is disabled");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3227
        check_signals = false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3228
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3229
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3230
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3231
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3232
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3233
// This is the fastest way to get thread cpu time on Linux.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3234
// Returns cpu time (user+sys) for any thread, not only for current.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3235
// POSIX compliant clocks are implemented in the kernels 2.6.16+.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3236
// It might work on 2.6.10+ with a special kernel/glibc patch.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3237
// For reference, please, see IEEE Std 1003.1-2004:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3238
//   http://www.unix.org/single_unix_specification
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3239
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3240
jlong os::Linux::fast_thread_cpu_time(clockid_t clockid) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3241
  struct timespec tp;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3242
  int rc = os::Linux::clock_gettime(clockid, &tp);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3243
  assert(rc == 0, "clock_gettime is expected to return 0 code");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3244
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3245
  return (tp.tv_sec * SEC_IN_NANOSECS) + tp.tv_nsec;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3246
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3247
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3248
/////
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3249
// glibc on Linux platform uses non-documented flag
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3250
// to indicate, that some special sort of signal
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3251
// trampoline is used.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3252
// We will never set this flag, and we should
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3253
// ignore this flag in our diagnostic
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3254
#ifdef SIGNIFICANT_SIGNAL_MASK
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3255
#undef SIGNIFICANT_SIGNAL_MASK
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3256
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3257
#define SIGNIFICANT_SIGNAL_MASK (~0x04000000)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3258
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3259
static const char* get_signal_handler_name(address handler,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3260
                                           char* buf, int buflen) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3261
  int offset;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3262
  bool found = os::dll_address_to_library_name(handler, buf, buflen, &offset);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3263
  if (found) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3264
    // skip directory names
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3265
    const char *p1, *p2;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3266
    p1 = buf;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3267
    size_t len = strlen(os::file_separator());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3268
    while ((p2 = strstr(p1, os::file_separator())) != NULL) p1 = p2 + len;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3269
    jio_snprintf(buf, buflen, "%s+0x%x", p1, offset);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3270
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3271
    jio_snprintf(buf, buflen, PTR_FORMAT, handler);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3272
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3273
  return buf;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3274
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3275
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3276
static void print_signal_handler(outputStream* st, int sig,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3277
                                 char* buf, size_t buflen) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3278
  struct sigaction sa;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3279
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3280
  sigaction(sig, NULL, &sa);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3281
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3282
  // See comment for SIGNIFICANT_SIGNAL_MASK define
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3283
  sa.sa_flags &= SIGNIFICANT_SIGNAL_MASK;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3284
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3285
  st->print("%s: ", os::exception_name(sig, buf, buflen));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3286
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3287
  address handler = (sa.sa_flags & SA_SIGINFO)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3288
    ? CAST_FROM_FN_PTR(address, sa.sa_sigaction)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3289
    : CAST_FROM_FN_PTR(address, sa.sa_handler);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3290
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3291
  if (handler == CAST_FROM_FN_PTR(address, SIG_DFL)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3292
    st->print("SIG_DFL");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3293
  } else if (handler == CAST_FROM_FN_PTR(address, SIG_IGN)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3294
    st->print("SIG_IGN");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3295
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3296
    st->print("[%s]", get_signal_handler_name(handler, buf, buflen));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3297
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3298
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3299
  st->print(", sa_mask[0]=" PTR32_FORMAT, *(uint32_t*)&sa.sa_mask);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3300
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3301
  address rh = VMError::get_resetted_sighandler(sig);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3302
  // May be, handler was resetted by VMError?
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3303
  if(rh != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3304
    handler = rh;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3305
    sa.sa_flags = VMError::get_resetted_sigflags(sig) & SIGNIFICANT_SIGNAL_MASK;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3306
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3307
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3308
  st->print(", sa_flags="   PTR32_FORMAT, sa.sa_flags);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3309
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3310
  // Check: is it our handler?
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3311
  if(handler == CAST_FROM_FN_PTR(address, (sa_sigaction_t)signalHandler) ||
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3312
     handler == CAST_FROM_FN_PTR(address, (sa_sigaction_t)SR_handler)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3313
    // It is our signal handler
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3314
    // check for flags, reset system-used one!
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3315
    if((int)sa.sa_flags != os::Linux::get_our_sigflags(sig)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3316
      st->print(
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3317
                ", flags was changed from " PTR32_FORMAT ", consider using jsig library",
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3318
                os::Linux::get_our_sigflags(sig));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3319
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3320
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3321
  st->cr();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3322
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3323
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3324
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3325
#define DO_SIGNAL_CHECK(sig) \
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3326
  if (!sigismember(&check_signal_done, sig)) \
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3327
    os::Linux::check_signal_handler(sig)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3328
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3329
// This method is a periodic task to check for misbehaving JNI applications
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3330
// under CheckJNI, we can add any periodic checks here
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3331
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3332
void os::run_periodic_checks() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3333
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3334
  if (check_signals == false) return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3335
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3336
  // SEGV and BUS if overridden could potentially prevent
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3337
  // generation of hs*.log in the event of a crash, debugging
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3338
  // such a case can be very challenging, so we absolutely
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3339
  // check the following for a good measure:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3340
  DO_SIGNAL_CHECK(SIGSEGV);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3341
  DO_SIGNAL_CHECK(SIGILL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3342
  DO_SIGNAL_CHECK(SIGFPE);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3343
  DO_SIGNAL_CHECK(SIGBUS);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3344
  DO_SIGNAL_CHECK(SIGPIPE);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3345
  DO_SIGNAL_CHECK(SIGXFSZ);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3346
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3347
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3348
  // ReduceSignalUsage allows the user to override these handlers
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3349
  // see comments at the very top and jvm_solaris.h
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3350
  if (!ReduceSignalUsage) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3351
    DO_SIGNAL_CHECK(SHUTDOWN1_SIGNAL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3352
    DO_SIGNAL_CHECK(SHUTDOWN2_SIGNAL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3353
    DO_SIGNAL_CHECK(SHUTDOWN3_SIGNAL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3354
    DO_SIGNAL_CHECK(BREAK_SIGNAL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3355
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3356
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3357
  DO_SIGNAL_CHECK(SR_signum);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3358
  DO_SIGNAL_CHECK(INTERRUPT_SIGNAL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3359
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3360
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3361
typedef int (*os_sigaction_t)(int, const struct sigaction *, struct sigaction *);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3362
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3363
static os_sigaction_t os_sigaction = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3364
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3365
void os::Linux::check_signal_handler(int sig) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3366
  char buf[O_BUFLEN];
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3367
  address jvmHandler = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3368
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3369
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3370
  struct sigaction act;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3371
  if (os_sigaction == NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3372
    // only trust the default sigaction, in case it has been interposed
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3373
    os_sigaction = (os_sigaction_t)dlsym(RTLD_DEFAULT, "sigaction");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3374
    if (os_sigaction == NULL) return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3375
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3376
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3377
  os_sigaction(sig, (struct sigaction*)NULL, &act);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3378
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3379
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3380
  act.sa_flags &= SIGNIFICANT_SIGNAL_MASK;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3381
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3382
  address thisHandler = (act.sa_flags & SA_SIGINFO)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3383
    ? CAST_FROM_FN_PTR(address, act.sa_sigaction)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3384
    : CAST_FROM_FN_PTR(address, act.sa_handler) ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3385
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3386
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3387
  switch(sig) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3388
  case SIGSEGV:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3389
  case SIGBUS:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3390
  case SIGFPE:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3391
  case SIGPIPE:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3392
  case SIGILL:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3393
  case SIGXFSZ:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3394
    jvmHandler = CAST_FROM_FN_PTR(address, (sa_sigaction_t)signalHandler);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3395
    break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3396
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3397
  case SHUTDOWN1_SIGNAL:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3398
  case SHUTDOWN2_SIGNAL:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3399
  case SHUTDOWN3_SIGNAL:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3400
  case BREAK_SIGNAL:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3401
    jvmHandler = (address)user_handler();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3402
    break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3403
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3404
  case INTERRUPT_SIGNAL:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3405
    jvmHandler = CAST_FROM_FN_PTR(address, SIG_DFL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3406
    break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3407
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3408
  default:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3409
    if (sig == SR_signum) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3410
      jvmHandler = CAST_FROM_FN_PTR(address, (sa_sigaction_t)SR_handler);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3411
    } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3412
      return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3413
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3414
    break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3415
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3416
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3417
  if (thisHandler != jvmHandler) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3418
    tty->print("Warning: %s handler ", exception_name(sig, buf, O_BUFLEN));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3419
    tty->print("expected:%s", get_signal_handler_name(jvmHandler, buf, O_BUFLEN));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3420
    tty->print_cr("  found:%s", get_signal_handler_name(thisHandler, buf, O_BUFLEN));
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
  } 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
  3424
    tty->print("Warning: %s handler flags ", exception_name(sig, buf, O_BUFLEN));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3425
    tty->print("expected:" PTR32_FORMAT, os::Linux::get_our_sigflags(sig));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3426
    tty->print_cr("  found:" PTR32_FORMAT, act.sa_flags);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3427
    // No need to check this sig any longer
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3428
    sigaddset(&check_signal_done, sig);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3429
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3430
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3431
  // Dump all the signal
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3432
  if (sigismember(&check_signal_done, sig)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3433
    print_signal_handlers(tty, buf, O_BUFLEN);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3434
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3435
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3436
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3437
extern void report_error(char* file_name, int line_no, char* title, char* format, ...);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3438
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3439
extern bool signal_name(int signo, char* buf, size_t len);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3440
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3441
const char* os::exception_name(int exception_code, char* buf, size_t size) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3442
  if (0 < exception_code && exception_code <= SIGRTMAX) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3443
    // signal
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3444
    if (!signal_name(exception_code, buf, size)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3445
      jio_snprintf(buf, size, "SIG%d", exception_code);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3446
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3447
    return buf;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3448
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3449
    return NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3450
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3451
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3452
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3453
// this is called _before_ the most of global arguments have been parsed
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3454
void os::init(void) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3455
  char dummy;   /* used to get a guess on initial stack address */
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3456
//  first_hrtime = gethrtime();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3457
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3458
  // With LinuxThreads the JavaMain thread pid (primordial thread)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3459
  // is different than the pid of the java launcher thread.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3460
  // So, on Linux, the launcher thread pid is passed to the VM
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3461
  // via the sun.java.launcher.pid property.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3462
  // Use this property instead of getpid() if it was correctly passed.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3463
  // See bug 6351349.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3464
  pid_t java_launcher_pid = (pid_t) Arguments::sun_java_launcher_pid();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3465
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3466
  _initial_pid = (java_launcher_pid > 0) ? java_launcher_pid : getpid();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3467
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3468
  clock_tics_per_sec = sysconf(_SC_CLK_TCK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3469
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3470
  init_random(1234567);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3471
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3472
  ThreadCritical::initialize();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3473
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3474
  Linux::set_page_size(sysconf(_SC_PAGESIZE));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3475
  if (Linux::page_size() == -1) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3476
    fatal1("os_linux.cpp: os::init: sysconf failed (%s)", strerror(errno));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3477
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3478
  init_page_sizes((size_t) Linux::page_size());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3479
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3480
  Linux::initialize_system_info();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3481
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3482
  // main_thread points to the aboriginal thread
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3483
  Linux::_main_thread = pthread_self();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3484
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3485
  Linux::clock_init();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3486
  initial_time_count = os::elapsed_counter();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3487
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3488
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3489
// To install functions for atexit system call
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3490
extern "C" {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3491
  static void perfMemory_exit_helper() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3492
    perfMemory_exit();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3493
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3494
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3495
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3496
// this is called _after_ the global arguments have been parsed
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3497
jint os::init_2(void)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3498
{
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3499
  Linux::fast_thread_clock_init();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3500
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3501
  // Allocate a single page and mark it as readable for safepoint polling
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3502
  address polling_page = (address) ::mmap(NULL, Linux::page_size(), PROT_READ, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3503
  guarantee( polling_page != MAP_FAILED, "os::init_2: failed to allocate polling page" );
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3504
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3505
  os::set_polling_page( polling_page );
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3506
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3507
#ifndef PRODUCT
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3508
  if(Verbose && PrintMiscellaneous)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3509
    tty->print("[SafePoint Polling address: " INTPTR_FORMAT "]\n", (intptr_t)polling_page);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3510
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3511
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3512
  if (!UseMembar) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3513
    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
  3514
    guarantee( mem_serialize_page != NULL, "mmap Failed for memory serialize page");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3515
    os::set_memory_serialize_page( mem_serialize_page );
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3516
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3517
#ifndef PRODUCT
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3518
    if(Verbose && PrintMiscellaneous)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3519
      tty->print("[Memory Serialize  Page address: " INTPTR_FORMAT "]\n", (intptr_t)mem_serialize_page);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3520
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3521
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3522
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3523
  FLAG_SET_DEFAULT(UseLargePages, os::large_page_init());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3524
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3525
  // initialize suspend/resume support - must do this before signal_sets_init()
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3526
  if (SR_initialize() != 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3527
    perror("SR_initialize failed");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3528
    return JNI_ERR;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3529
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3530
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3531
  Linux::signal_sets_init();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3532
  Linux::install_signal_handlers();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3533
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3534
  size_t threadStackSizeInBytes = ThreadStackSize * K;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3535
  if (threadStackSizeInBytes != 0 &&
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3536
      threadStackSizeInBytes < Linux::min_stack_allowed) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3537
        tty->print_cr("\nThe stack size specified is too small, "
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3538
                      "Specify at least %dk",
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3539
                      Linux::min_stack_allowed / K);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3540
        return JNI_ERR;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3541
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3542
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3543
  // Make the stack size a multiple of the page size so that
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3544
  // the yellow/red zones can be guarded.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3545
  JavaThread::set_stack_size_at_create(round_to(threadStackSizeInBytes,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3546
        vm_page_size()));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3547
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3548
  Linux::capture_initial_stack(JavaThread::stack_size_at_create());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3549
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3550
  Linux::libpthread_init();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3551
  if (PrintMiscellaneous && (Verbose || WizardMode)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3552
     tty->print_cr("[HotSpot is running with %s, %s(%s)]\n",
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3553
          Linux::glibc_version(), Linux::libpthread_version(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3554
          Linux::is_floating_stack() ? "floating stack" : "fixed stack");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3555
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3556
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3557
  if (MaxFDLimit) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3558
    // set the number of file descriptors to max. print out error
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3559
    // if getrlimit/setrlimit fails but continue regardless.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3560
    struct rlimit nbr_files;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3561
    int status = getrlimit(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 getrlimit failed");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3565
    } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3566
      nbr_files.rlim_cur = nbr_files.rlim_max;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3567
      status = setrlimit(RLIMIT_NOFILE, &nbr_files);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3568
      if (status != 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3569
        if (PrintMiscellaneous && (Verbose || WizardMode))
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3570
          perror("os::init_2 setrlimit failed");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3571
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3572
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3573
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3574
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3575
  // Initialize lock used to serialize thread creation (see os::create_thread)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3576
  Linux::set_createThread_lock(new Mutex(Mutex::leaf, "createThread_lock", false));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3577
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3578
  // Initialize HPI.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3579
  jint hpi_result = hpi::initialize();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3580
  if (hpi_result != JNI_OK) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3581
    tty->print_cr("There was an error trying to initialize the HPI library.");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3582
    return hpi_result;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3583
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3584
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3585
  // at-exit methods are called in the reverse order of their registration.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3586
  // atexit functions are called on return from main or as a result of a
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3587
  // call to exit(3C). There can be only 32 of these functions registered
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3588
  // and atexit() does not set errno.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3589
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3590
  if (PerfAllowAtExitRegistration) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3591
    // only register atexit functions if PerfAllowAtExitRegistration is set.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3592
    // atexit functions can be delayed until process exit time, which
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3593
    // can be problematic for embedded VM situations. Embedded VMs should
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3594
    // call DestroyJavaVM() to assure that VM resources are released.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3595
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3596
    // note: perfMemory_exit_helper atexit function may be removed in
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3597
    // the future if the appropriate cleanup code can be added to the
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3598
    // VM_Exit VMOperation's doit method.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3599
    if (atexit(perfMemory_exit_helper) != 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3600
      warning("os::init2 atexit(perfMemory_exit_helper) failed");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3601
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3602
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3603
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3604
  // initialize thread priority policy
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3605
  prio_init();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3606
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3607
  return JNI_OK;
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 unreadable
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3611
void os::make_polling_page_unreadable(void) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3612
  if( !guard_memory((char*)_polling_page, Linux::page_size()) )
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3613
    fatal("Could not disable 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
// Mark the polling page as readable
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3617
void os::make_polling_page_readable(void) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3618
  if( !protect_memory((char *)_polling_page, Linux::page_size()) )
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3619
    fatal("Could not enable polling page");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3620
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3621
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3622
int os::active_processor_count() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3623
  // Linux doesn't yet have a (official) notion of processor sets,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3624
  // so just return the number of online processors.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3625
  int online_cpus = ::sysconf(_SC_NPROCESSORS_ONLN);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3626
  assert(online_cpus > 0 && online_cpus <= processor_count(), "sanity check");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3627
  return online_cpus;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3628
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3629
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3630
bool os::distribute_processes(uint length, uint* distribution) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3631
  // Not yet implemented.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3632
  return false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3633
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3634
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3635
bool os::bind_to_processor(uint processor_id) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3636
  // Not yet implemented.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3637
  return false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3638
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3639
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3640
///
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3641
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3642
// Suspends the target using the signal mechanism and then grabs the PC before
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3643
// resuming the target. Used by the flat-profiler only
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3644
ExtendedPC os::get_thread_pc(Thread* thread) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3645
  // Make sure that it is called by the watcher for the VMThread
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3646
  assert(Thread::current()->is_Watcher_thread(), "Must be watcher");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3647
  assert(thread->is_VM_thread(), "Can only be called for VMThread");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3648
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3649
  ExtendedPC epc;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3650
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3651
  OSThread* osthread = thread->osthread();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3652
  if (do_suspend(osthread)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3653
    if (osthread->ucontext() != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3654
      epc = os::Linux::ucontext_get_pc(osthread->ucontext());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3655
    } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3656
      // NULL context is unexpected, double-check this is the VMThread
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3657
      guarantee(thread->is_VM_thread(), "can only be called for VMThread");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3658
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3659
    do_resume(osthread);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3660
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3661
  // failure means pthread_kill failed for some reason - arguably this is
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3662
  // a fatal problem, but such problems are ignored elsewhere
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3663
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3664
  return epc;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3665
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3666
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3667
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
  3668
{
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3669
   if (is_NPTL()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3670
      return pthread_cond_timedwait(_cond, _mutex, _abstime);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3671
   } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3672
#ifndef IA64
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3673
      // 6292965: LinuxThreads pthread_cond_timedwait() resets FPU control
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3674
      // word back to default 64bit precision if condvar is signaled. Java
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3675
      // wants 53bit precision.  Save and restore current value.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3676
      int fpu = get_fpu_control_word();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3677
#endif // IA64
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3678
      int status = pthread_cond_timedwait(_cond, _mutex, _abstime);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3679
#ifndef IA64
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3680
      set_fpu_control_word(fpu);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3681
#endif // IA64
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3682
      return status;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3683
   }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3684
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3685
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3686
////////////////////////////////////////////////////////////////////////////////
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3687
// debug support
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3688
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3689
#ifndef PRODUCT
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3690
static address same_page(address x, address y) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3691
  int page_bits = -os::vm_page_size();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3692
  if ((intptr_t(x) & page_bits) == (intptr_t(y) & page_bits))
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3693
    return x;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3694
  else if (x > y)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3695
    return (address)(intptr_t(y) | ~page_bits) + 1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3696
  else
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3697
    return (address)(intptr_t(y) & page_bits);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3698
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3699
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3700
bool os::find(address addr) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3701
  Dl_info dlinfo;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3702
  memset(&dlinfo, 0, sizeof(dlinfo));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3703
  if (dladdr(addr, &dlinfo)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3704
    tty->print(PTR_FORMAT ": ", addr);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3705
    if (dlinfo.dli_sname != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3706
      tty->print("%s+%#x", dlinfo.dli_sname,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3707
                 addr - (intptr_t)dlinfo.dli_saddr);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3708
    } else if (dlinfo.dli_fname) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3709
      tty->print("<offset %#x>", addr - (intptr_t)dlinfo.dli_fbase);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3710
    } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3711
      tty->print("<absolute address>");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3712
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3713
    if (dlinfo.dli_fname) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3714
      tty->print(" in %s", dlinfo.dli_fname);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3715
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3716
    if (dlinfo.dli_fbase) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3717
      tty->print(" at " PTR_FORMAT, dlinfo.dli_fbase);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3718
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3719
    tty->cr();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3720
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3721
    if (Verbose) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3722
      // decode some bytes around the PC
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3723
      address begin = same_page(addr-40, addr);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3724
      address end   = same_page(addr+40, addr);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3725
      address       lowest = (address) dlinfo.dli_sname;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3726
      if (!lowest)  lowest = (address) dlinfo.dli_fbase;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3727
      if (begin < lowest)  begin = lowest;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3728
      Dl_info dlinfo2;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3729
      if (dladdr(end, &dlinfo2) && dlinfo2.dli_saddr != dlinfo.dli_saddr
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3730
          && end > dlinfo2.dli_saddr && dlinfo2.dli_saddr > begin)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3731
        end = (address) dlinfo2.dli_saddr;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3732
      Disassembler::decode(begin, end);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3733
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3734
    return true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3735
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3736
  return false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3737
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3738
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3739
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3740
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3741
////////////////////////////////////////////////////////////////////////////////
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3742
// misc
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3743
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3744
// This does not do anything on Linux. This is basically a hook for being
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3745
// able to use structured exception handling (thread-local exception filters)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3746
// on, e.g., Win32.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3747
void
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3748
os::os_exception_wrapper(java_call_t f, JavaValue* value, methodHandle* method,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3749
                         JavaCallArguments* args, Thread* thread) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3750
  f(value, method, args, thread);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3751
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3752
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3753
void os::print_statistics() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3754
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3755
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3756
int os::message_box(const char* title, const char* message) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3757
  int i;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3758
  fdStream err(defaultStream::error_fd());
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
  err.print_raw_cr(title);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3762
  for (i = 0; i < 78; i++) err.print_raw("-");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3763
  err.cr();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3764
  err.print_raw_cr(message);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3765
  for (i = 0; i < 78; i++) err.print_raw("=");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3766
  err.cr();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3767
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3768
  char buf[16];
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3769
  // Prevent process from exiting upon "read error" without consuming all CPU
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3770
  while (::read(0, buf, sizeof(buf)) <= 0) { ::sleep(100); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3771
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3772
  return buf[0] == 'y' || buf[0] == 'Y';
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3773
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3774
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3775
int os::stat(const char *path, struct stat *sbuf) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3776
  char pathbuf[MAX_PATH];
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3777
  if (strlen(path) > MAX_PATH - 1) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3778
    errno = ENAMETOOLONG;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3779
    return -1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3780
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3781
  hpi::native_path(strcpy(pathbuf, path));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3782
  return ::stat(pathbuf, sbuf);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3783
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3784
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3785
bool os::check_heap(bool force) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3786
  return true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3787
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3788
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3789
int local_vsnprintf(char* buf, size_t count, const char* format, va_list args) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3790
  return ::vsnprintf(buf, count, format, args);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3791
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3792
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3793
// Is a (classpath) directory empty?
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3794
bool os::dir_is_empty(const char* path) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3795
  DIR *dir = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3796
  struct dirent *ptr;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3797
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3798
  dir = opendir(path);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3799
  if (dir == NULL) return true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3800
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3801
  /* Scan the directory */
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3802
  bool result = true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3803
  char buf[sizeof(struct dirent) + MAX_PATH];
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3804
  while (result && (ptr = ::readdir(dir)) != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3805
    if (strcmp(ptr->d_name, ".") != 0 && strcmp(ptr->d_name, "..") != 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3806
      result = false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3807
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3808
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3809
  closedir(dir);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3810
  return result;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3811
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3812
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3813
// create binary file, rewriting existing file if required
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3814
int os::create_binary_file(const char* path, bool rewrite_existing) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3815
  int oflags = O_WRONLY | O_CREAT;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3816
  if (!rewrite_existing) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3817
    oflags |= O_EXCL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3818
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3819
  return ::open64(path, oflags, S_IREAD | S_IWRITE);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3820
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3821
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3822
// return current position of file pointer
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3823
jlong os::current_file_offset(int fd) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3824
  return (jlong)::lseek64(fd, (off64_t)0, SEEK_CUR);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3825
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3826
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3827
// move file pointer to the specified offset
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3828
jlong os::seek_to_file_offset(int fd, jlong offset) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3829
  return (jlong)::lseek64(fd, (off64_t)offset, SEEK_SET);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3830
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3831
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3832
// Map a block of memory.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3833
char* os::map_memory(int fd, const char* file_name, size_t file_offset,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3834
                     char *addr, size_t bytes, bool read_only,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3835
                     bool allow_exec) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3836
  int prot;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3837
  int flags;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3838
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3839
  if (read_only) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3840
    prot = PROT_READ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3841
    flags = MAP_SHARED;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3842
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3843
    prot = PROT_READ | PROT_WRITE;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3844
    flags = MAP_PRIVATE;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3845
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3846
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3847
  if (allow_exec) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3848
    prot |= PROT_EXEC;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3849
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3850
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3851
  if (addr != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3852
    flags |= MAP_FIXED;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3853
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3854
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3855
  char* mapped_address = (char*)mmap(addr, (size_t)bytes, prot, flags,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3856
                                     fd, file_offset);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3857
  if (mapped_address == MAP_FAILED) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3858
    return NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3859
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3860
  return mapped_address;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3861
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3862
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3863
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3864
// Remap a block of memory.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3865
char* os::remap_memory(int fd, const char* file_name, size_t file_offset,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3866
                       char *addr, size_t bytes, bool read_only,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3867
                       bool allow_exec) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3868
  // same as map_memory() on this OS
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3869
  return os::map_memory(fd, file_name, file_offset, addr, bytes, read_only,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3870
                        allow_exec);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3871
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3872
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3873
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3874
// Unmap a block of memory.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3875
bool os::unmap_memory(char* addr, size_t bytes) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3876
  return munmap(addr, bytes) == 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3877
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3878
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3879
static jlong slow_thread_cpu_time(Thread *thread, bool user_sys_cpu_time);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3880
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3881
static clockid_t thread_cpu_clockid(Thread* thread) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3882
  pthread_t tid = thread->osthread()->pthread_id();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3883
  clockid_t clockid;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3884
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3885
  // Get thread clockid
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3886
  int rc = os::Linux::pthread_getcpuclockid(tid, &clockid);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3887
  assert(rc == 0, "pthread_getcpuclockid is expected to return 0 code");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3888
  return clockid;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3889
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3890
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3891
// current_thread_cpu_time(bool) and thread_cpu_time(Thread*, bool)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3892
// are used by JVM M&M and JVMTI to get user+sys or user CPU time
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3893
// of a thread.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3894
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3895
// current_thread_cpu_time() and thread_cpu_time(Thread*) returns
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3896
// the fast estimate available on the platform.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3897
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3898
jlong os::current_thread_cpu_time() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3899
  if (os::Linux::supports_fast_thread_cpu_time()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3900
    return os::Linux::fast_thread_cpu_time(CLOCK_THREAD_CPUTIME_ID);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3901
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3902
    // return user + sys since the cost is the same
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3903
    return slow_thread_cpu_time(Thread::current(), true /* user + sys */);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3904
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3905
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3906
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3907
jlong os::thread_cpu_time(Thread* thread) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3908
  // consistent with what current_thread_cpu_time() returns
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3909
  if (os::Linux::supports_fast_thread_cpu_time()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3910
    return os::Linux::fast_thread_cpu_time(thread_cpu_clockid(thread));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3911
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3912
    return slow_thread_cpu_time(thread, true /* user + sys */);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3913
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3914
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3915
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3916
jlong os::current_thread_cpu_time(bool user_sys_cpu_time) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3917
  if (user_sys_cpu_time && os::Linux::supports_fast_thread_cpu_time()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3918
    return os::Linux::fast_thread_cpu_time(CLOCK_THREAD_CPUTIME_ID);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3919
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3920
    return slow_thread_cpu_time(Thread::current(), user_sys_cpu_time);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3921
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3922
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3923
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3924
jlong os::thread_cpu_time(Thread *thread, bool user_sys_cpu_time) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3925
  if (user_sys_cpu_time && os::Linux::supports_fast_thread_cpu_time()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3926
    return os::Linux::fast_thread_cpu_time(thread_cpu_clockid(thread));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3927
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3928
    return slow_thread_cpu_time(thread, user_sys_cpu_time);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3929
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3930
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3931
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3932
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3933
//  -1 on error.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3934
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3935
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3936
static jlong slow_thread_cpu_time(Thread *thread, bool user_sys_cpu_time) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3937
  static bool proc_pid_cpu_avail = true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3938
  static bool proc_task_unchecked = true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3939
  static const char *proc_stat_path = "/proc/%d/stat";
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3940
  pid_t  tid = thread->osthread()->thread_id();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3941
  int i;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3942
  char *s;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3943
  char stat[2048];
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3944
  int statlen;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3945
  char proc_name[64];
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3946
  int count;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3947
  long sys_time, user_time;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3948
  char string[64];
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3949
  int idummy;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3950
  long ldummy;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3951
  FILE *fp;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3952
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3953
  // We first try accessing /proc/<pid>/cpu since this is faster to
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3954
  // process.  If this file is not present (linux kernels 2.5 and above)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3955
  // then we open /proc/<pid>/stat.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3956
  if ( proc_pid_cpu_avail ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3957
    sprintf(proc_name, "/proc/%d/cpu", tid);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3958
    fp =  fopen(proc_name, "r");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3959
    if ( fp != NULL ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3960
      count = fscanf( fp, "%s %lu %lu\n", string, &user_time, &sys_time);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3961
      fclose(fp);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3962
      if ( count != 3 ) return -1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3963
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3964
      if (user_sys_cpu_time) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3965
        return ((jlong)sys_time + (jlong)user_time) * (1000000000 / clock_tics_per_sec);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3966
      } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3967
        return (jlong)user_time * (1000000000 / clock_tics_per_sec);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3968
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3969
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3970
    else proc_pid_cpu_avail = false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3971
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3972
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3973
  // The /proc/<tid>/stat aggregates per-process usage on
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3974
  // new Linux kernels 2.6+ where NPTL is supported.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3975
  // The /proc/self/task/<tid>/stat still has the per-thread usage.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3976
  // See bug 6328462.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3977
  // There can be no directory /proc/self/task on kernels 2.4 with NPTL
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3978
  // and possibly in some other cases, so we check its availability.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3979
  if (proc_task_unchecked && os::Linux::is_NPTL()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3980
    // This is executed only once
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3981
    proc_task_unchecked = false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3982
    fp = fopen("/proc/self/task", "r");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3983
    if (fp != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3984
      proc_stat_path = "/proc/self/task/%d/stat";
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3985
      fclose(fp);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3986
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3987
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3988
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3989
  sprintf(proc_name, proc_stat_path, tid);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3990
  fp = fopen(proc_name, "r");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3991
  if ( fp == NULL ) return -1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3992
  statlen = fread(stat, 1, 2047, fp);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3993
  stat[statlen] = '\0';
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3994
  fclose(fp);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3995
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3996
  // Skip pid and the command string. Note that we could be dealing with
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3997
  // weird command names, e.g. user could decide to rename java launcher
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3998
  // to "java 1.4.2 :)", then the stat file would look like
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3999
  //                1234 (java 1.4.2 :)) R ... ...
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4000
  // We don't really need to know the command string, just find the last
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4001
  // occurrence of ")" and then start parsing from there. See bug 4726580.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4002
  s = strrchr(stat, ')');
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4003
  i = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4004
  if (s == NULL ) return -1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4005
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4006
  // Skip blank chars
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4007
  do s++; while (isspace(*s));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4008
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4009
  count = sscanf(s,"%c %d %d %d %d %d %lu %lu %lu %lu %lu %lu %lu",
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4010
                 &idummy, &idummy, &idummy, &idummy, &idummy, &idummy,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4011
                 &ldummy, &ldummy, &ldummy, &ldummy, &ldummy,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4012
                 &user_time, &sys_time);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4013
  if ( count != 13 ) return -1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4014
  if (user_sys_cpu_time) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4015
    return ((jlong)sys_time + (jlong)user_time) * (1000000000 / clock_tics_per_sec);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4016
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4017
    return (jlong)user_time * (1000000000 / clock_tics_per_sec);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4018
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4019
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4020
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4021
void os::current_thread_cpu_time_info(jvmtiTimerInfo *info_ptr) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4022
  info_ptr->max_value = ALL_64_BITS;       // will not wrap in less than 64 bits
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4023
  info_ptr->may_skip_backward = false;     // elapsed time not wall time
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4024
  info_ptr->may_skip_forward = false;      // elapsed time not wall time
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4025
  info_ptr->kind = JVMTI_TIMER_TOTAL_CPU;  // user+system time is returned
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4026
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4027
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4028
void os::thread_cpu_time_info(jvmtiTimerInfo *info_ptr) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4029
  info_ptr->max_value = ALL_64_BITS;       // will not wrap in less than 64 bits
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4030
  info_ptr->may_skip_backward = false;     // elapsed time not wall time
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4031
  info_ptr->may_skip_forward = false;      // elapsed time not wall time
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4032
  info_ptr->kind = JVMTI_TIMER_TOTAL_CPU;  // user+system time is returned
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4033
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4034
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4035
bool os::is_thread_cpu_time_supported() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4036
  return true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4037
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4038
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4039
// System loadavg support.  Returns -1 if load average cannot be obtained.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4040
// Linux doesn't yet have a (official) notion of processor sets,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4041
// so just return the system wide load average.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4042
int os::loadavg(double loadavg[], int nelem) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4043
  return ::getloadavg(loadavg, nelem);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4044
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4045
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4046
void os::pause() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4047
  char filename[MAX_PATH];
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4048
  if (PauseAtStartupFile && PauseAtStartupFile[0]) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4049
    jio_snprintf(filename, MAX_PATH, PauseAtStartupFile);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4050
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4051
    jio_snprintf(filename, MAX_PATH, "./vm.paused.%d", current_process_id());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4052
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4053
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4054
  int fd = ::open(filename, O_WRONLY | O_CREAT | O_TRUNC, 0666);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4055
  if (fd != -1) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4056
    struct stat buf;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4057
    close(fd);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4058
    while (::stat(filename, &buf) == 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4059
      (void)::poll(NULL, 0, 100);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4060
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4061
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4062
    jio_fprintf(stderr,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4063
      "Could not open pause file '%s', continuing immediately.\n", filename);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4064
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4065
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4066
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4067
extern "C" {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4068
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4069
/**
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4070
 * NOTE: the following code is to keep the green threads code
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4071
 * in the libjava.so happy. Once the green threads is removed,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4072
 * these code will no longer be needed.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4073
 */
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4074
int
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4075
jdk_waitpid(pid_t pid, int* status, int options) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4076
    return waitpid(pid, status, options);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4077
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4078
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4079
int
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4080
fork1() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4081
    return fork();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4082
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4083
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4084
int
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4085
jdk_sem_init(sem_t *sem, int pshared, unsigned int value) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4086
    return sem_init(sem, pshared, value);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4087
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4088
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4089
int
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4090
jdk_sem_post(sem_t *sem) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4091
    return sem_post(sem);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4092
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4093
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4094
int
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4095
jdk_sem_wait(sem_t *sem) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4096
    return sem_wait(sem);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4097
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4098
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4099
int
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4100
jdk_pthread_sigmask(int how , const sigset_t* newmask, sigset_t* oldmask) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4101
    return pthread_sigmask(how , newmask, oldmask);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4102
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4103
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4104
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4105
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4106
// Refer to the comments in os_solaris.cpp park-unpark.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4107
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4108
// Beware -- Some versions of NPTL embody a flaw where pthread_cond_timedwait() can
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4109
// hang indefinitely.  For instance NPTL 0.60 on 2.4.21-4ELsmp is vulnerable.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4110
// For specifics regarding the bug see GLIBC BUGID 261237 :
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4111
//    http://www.mail-archive.com/debian-glibc@lists.debian.org/msg10837.html.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4112
// Briefly, pthread_cond_timedwait() calls with an expiry time that's not in the future
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4113
// will either hang or corrupt the condvar, resulting in subsequent hangs if the condvar
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4114
// is used.  (The simple C test-case provided in the GLIBC bug report manifests the
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4115
// hang).  The JVM is vulernable via sleep(), Object.wait(timo), LockSupport.parkNanos()
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4116
// and monitorenter when we're using 1-0 locking.  All those operations may result in
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4117
// calls to pthread_cond_timedwait().  Using LD_ASSUME_KERNEL to use an older version
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4118
// of libpthread avoids the problem, but isn't practical.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4119
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4120
// Possible remedies:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4121
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4122
// 1.   Establish a minimum relative wait time.  50 to 100 msecs seems to work.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4123
//      This is palliative and probabilistic, however.  If the thread is preempted
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4124
//      between the call to compute_abstime() and pthread_cond_timedwait(), more
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4125
//      than the minimum period may have passed, and the abstime may be stale (in the
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4126
//      past) resultin in a hang.   Using this technique reduces the odds of a hang
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4127
//      but the JVM is still vulnerable, particularly on heavily loaded systems.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4128
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4129
// 2.   Modify park-unpark to use per-thread (per ParkEvent) pipe-pairs instead
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4130
//      of the usual flag-condvar-mutex idiom.  The write side of the pipe is set
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4131
//      NDELAY. unpark() reduces to write(), park() reduces to read() and park(timo)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4132
//      reduces to poll()+read().  This works well, but consumes 2 FDs per extant
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4133
//      thread.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4134
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4135
// 3.   Embargo pthread_cond_timedwait() and implement a native "chron" thread
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4136
//      that manages timeouts.  We'd emulate pthread_cond_timedwait() by enqueuing
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4137
//      a timeout request to the chron thread and then blocking via pthread_cond_wait().
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4138
//      This also works well.  In fact it avoids kernel-level scalability impediments
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4139
//      on certain platforms that don't handle lots of active pthread_cond_timedwait()
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4140
//      timers in a graceful fashion.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4141
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4142
// 4.   When the abstime value is in the past it appears that control returns
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4143
//      correctly from pthread_cond_timedwait(), but the condvar is left corrupt.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4144
//      Subsequent timedwait/wait calls may hang indefinitely.  Given that, we
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4145
//      can avoid the problem by reinitializing the condvar -- by cond_destroy()
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4146
//      followed by cond_init() -- after all calls to pthread_cond_timedwait().
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4147
//      It may be possible to avoid reinitialization by checking the return
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4148
//      value from pthread_cond_timedwait().  In addition to reinitializing the
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4149
//      condvar we must establish the invariant that cond_signal() is only called
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4150
//      within critical sections protected by the adjunct mutex.  This prevents
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4151
//      cond_signal() from "seeing" a condvar that's in the midst of being
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4152
//      reinitialized or that is corrupt.  Sadly, this invariant obviates the
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4153
//      desirable signal-after-unlock optimization that avoids futile context switching.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4154
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4155
//      I'm also concerned that some versions of NTPL might allocate an auxilliary
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4156
//      structure when a condvar is used or initialized.  cond_destroy()  would
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4157
//      release the helper structure.  Our reinitialize-after-timedwait fix
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4158
//      put excessive stress on malloc/free and locks protecting the c-heap.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4159
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4160
// We currently use (4).  See the WorkAroundNTPLTimedWaitHang flag.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4161
// It may be possible to refine (4) by checking the kernel and NTPL verisons
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4162
// and only enabling the work-around for vulnerable environments.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4163
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4164
// utility to compute the abstime argument to timedwait:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4165
// millis is the relative timeout time
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4166
// abstime will be the absolute timeout time
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4167
// TODO: replace compute_abstime() with unpackTime()
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4168
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4169
static struct timespec* compute_abstime(timespec* abstime, jlong millis) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4170
  if (millis < 0)  millis = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4171
  struct timeval now;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4172
  int status = gettimeofday(&now, NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4173
  assert(status == 0, "gettimeofday");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4174
  jlong seconds = millis / 1000;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4175
  millis %= 1000;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4176
  if (seconds > 50000000) { // see man cond_timedwait(3T)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4177
    seconds = 50000000;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4178
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4179
  abstime->tv_sec = now.tv_sec  + seconds;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4180
  long       usec = now.tv_usec + millis * 1000;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4181
  if (usec >= 1000000) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4182
    abstime->tv_sec += 1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4183
    usec -= 1000000;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4184
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4185
  abstime->tv_nsec = usec * 1000;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4186
  return abstime;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4187
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4188
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4189
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4190
// Test-and-clear _Event, always leaves _Event set to 0, returns immediately.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4191
// Conceptually TryPark() should be equivalent to park(0).
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4192
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4193
int os::PlatformEvent::TryPark() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4194
  for (;;) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4195
    const int v = _Event ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4196
    guarantee ((v == 0) || (v == 1), "invariant") ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4197
    if (Atomic::cmpxchg (0, &_Event, v) == v) return v  ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4198
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4199
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4200
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4201
void os::PlatformEvent::park() {       // AKA "down()"
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4202
  // Invariant: Only the thread associated with the Event/PlatformEvent
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4203
  // may call park().
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4204
  // TODO: assert that _Assoc != NULL or _Assoc == Self
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4205
  int v ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4206
  for (;;) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4207
      v = _Event ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4208
      if (Atomic::cmpxchg (v-1, &_Event, v) == v) break ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4209
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4210
  guarantee (v >= 0, "invariant") ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4211
  if (v == 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4212
     // Do this the hard way by blocking ...
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4213
     int status = pthread_mutex_lock(_mutex);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4214
     assert_status(status == 0, status, "mutex_lock");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4215
     guarantee (_nParked == 0, "invariant") ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4216
     ++ _nParked ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4217
     while (_Event < 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4218
        status = pthread_cond_wait(_cond, _mutex);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4219
        // for some reason, under 2.7 lwp_cond_wait() may return ETIME ...
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4220
        // Treat this the same as if the wait was interrupted
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4221
        if (status == ETIME) { status = EINTR; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4222
        assert_status(status == 0 || status == EINTR, status, "cond_wait");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4223
     }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4224
     -- _nParked ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4225
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4226
    // In theory we could move the ST of 0 into _Event past the unlock(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4227
    // but then we'd need a MEMBAR after the ST.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4228
    _Event = 0 ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4229
     status = pthread_mutex_unlock(_mutex);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4230
     assert_status(status == 0, status, "mutex_unlock");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4231
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4232
  guarantee (_Event >= 0, "invariant") ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4233
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4234
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4235
int os::PlatformEvent::park(jlong millis) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4236
  guarantee (_nParked == 0, "invariant") ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4237
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4238
  int v ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4239
  for (;;) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4240
      v = _Event ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4241
      if (Atomic::cmpxchg (v-1, &_Event, v) == v) break ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4242
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4243
  guarantee (v >= 0, "invariant") ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4244
  if (v != 0) return OS_OK ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4245
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4246
  // We do this the hard way, by blocking the thread.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4247
  // Consider enforcing a minimum timeout value.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4248
  struct timespec abst;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4249
  compute_abstime(&abst, millis);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4250
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4251
  int ret = OS_TIMEOUT;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4252
  int status = pthread_mutex_lock(_mutex);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4253
  assert_status(status == 0, status, "mutex_lock");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4254
  guarantee (_nParked == 0, "invariant") ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4255
  ++_nParked ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4256
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4257
  // Object.wait(timo) will return because of
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4258
  // (a) notification
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4259
  // (b) timeout
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4260
  // (c) thread.interrupt
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4261
  //
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4262
  // Thread.interrupt and object.notify{All} both call Event::set.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4263
  // That is, we treat thread.interrupt as a special case of notification.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4264
  // The underlying Solaris implementation, cond_timedwait, admits
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4265
  // spurious/premature wakeups, but the JLS/JVM spec prevents the
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4266
  // JVM from making those visible to Java code.  As such, we must
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4267
  // filter out spurious wakeups.  We assume all ETIME returns are valid.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4268
  //
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4269
  // TODO: properly differentiate simultaneous notify+interrupt.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4270
  // In that case, we should propagate the notify to another waiter.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4271
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4272
  while (_Event < 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4273
    status = os::Linux::safe_cond_timedwait(_cond, _mutex, &abst);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4274
    if (status != 0 && WorkAroundNPTLTimedWaitHang) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4275
      pthread_cond_destroy (_cond);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4276
      pthread_cond_init (_cond, NULL) ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4277
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4278
    assert_status(status == 0 || status == EINTR ||
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4279
                  status == ETIME || status == ETIMEDOUT,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4280
                  status, "cond_timedwait");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4281
    if (!FilterSpuriousWakeups) break ;                 // previous semantics
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4282
    if (status == ETIME || status == ETIMEDOUT) break ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4283
    // We consume and ignore EINTR and spurious wakeups.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4284
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4285
  --_nParked ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4286
  if (_Event >= 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4287
     ret = OS_OK;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4288
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4289
  _Event = 0 ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4290
  status = pthread_mutex_unlock(_mutex);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4291
  assert_status(status == 0, status, "mutex_unlock");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4292
  assert (_nParked == 0, "invariant") ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4293
  return ret;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4294
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4295
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4296
void os::PlatformEvent::unpark() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4297
  int v, AnyWaiters ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4298
  for (;;) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4299
      v = _Event ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4300
      if (v > 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4301
         // The LD of _Event could have reordered or be satisfied
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4302
         // by a read-aside from this processor's write buffer.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4303
         // To avoid problems execute a barrier and then
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4304
         // ratify the value.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4305
         OrderAccess::fence() ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4306
         if (_Event == v) return ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4307
         continue ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4308
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4309
      if (Atomic::cmpxchg (v+1, &_Event, v) == v) break ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4310
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4311
  if (v < 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4312
     // Wait for the thread associated with the event to vacate
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4313
     int status = pthread_mutex_lock(_mutex);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4314
     assert_status(status == 0, status, "mutex_lock");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4315
     AnyWaiters = _nParked ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4316
     assert (AnyWaiters == 0 || AnyWaiters == 1, "invariant") ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4317
     if (AnyWaiters != 0 && WorkAroundNPTLTimedWaitHang) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4318
        AnyWaiters = 0 ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4319
        pthread_cond_signal (_cond);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4320
     }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4321
     status = pthread_mutex_unlock(_mutex);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4322
     assert_status(status == 0, status, "mutex_unlock");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4323
     if (AnyWaiters != 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4324
        status = pthread_cond_signal(_cond);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4325
        assert_status(status == 0, status, "cond_signal");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4326
     }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4327
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4328
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4329
  // Note that we signal() _after dropping the lock for "immortal" Events.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4330
  // This is safe and avoids a common class of  futile wakeups.  In rare
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4331
  // circumstances this can cause a thread to return prematurely from
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4332
  // cond_{timed}wait() but the spurious wakeup is benign and the victim will
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4333
  // simply re-test the condition and re-park itself.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4334
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4335
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4336
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4337
// JSR166
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4338
// -------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4339
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4340
/*
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4341
 * The solaris and linux implementations of park/unpark are fairly
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4342
 * conservative for now, but can be improved. They currently use a
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4343
 * mutex/condvar pair, plus a a count.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4344
 * Park decrements count if > 0, else does a condvar wait.  Unpark
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4345
 * sets count to 1 and signals condvar.  Only one thread ever waits
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4346
 * on the condvar. Contention seen when trying to park implies that someone
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4347
 * is unparking you, so don't wait. And spurious returns are fine, so there
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4348
 * is no need to track notifications.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4349
 */
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4350
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4351
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4352
#define NANOSECS_PER_SEC 1000000000
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4353
#define NANOSECS_PER_MILLISEC 1000000
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4354
#define MAX_SECS 100000000
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4355
/*
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4356
 * This code is common to linux and solaris and will be moved to a
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4357
 * common place in dolphin.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4358
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4359
 * The passed in time value is either a relative time in nanoseconds
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4360
 * or an absolute time in milliseconds. Either way it has to be unpacked
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4361
 * into suitable seconds and nanoseconds components and stored in the
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4362
 * given timespec structure.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4363
 * Given time is a 64-bit value and the time_t used in the timespec is only
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4364
 * a signed-32-bit value (except on 64-bit Linux) we have to watch for
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4365
 * overflow if times way in the future are given. Further on Solaris versions
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4366
 * prior to 10 there is a restriction (see cond_timedwait) that the specified
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4367
 * number of seconds, in abstime, is less than current_time  + 100,000,000.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4368
 * As it will be 28 years before "now + 100000000" will overflow we can
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4369
 * ignore overflow and just impose a hard-limit on seconds using the value
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4370
 * of "now + 100,000,000". This places a limit on the timeout of about 3.17
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4371
 * years from "now".
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4372
 */
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4373
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4374
static void unpackTime(timespec* absTime, bool isAbsolute, jlong time) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4375
  assert (time > 0, "convertTime");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4376
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4377
  struct timeval now;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4378
  int status = gettimeofday(&now, NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4379
  assert(status == 0, "gettimeofday");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4380
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4381
  time_t max_secs = now.tv_sec + MAX_SECS;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4382
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4383
  if (isAbsolute) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4384
    jlong secs = time / 1000;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4385
    if (secs > max_secs) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4386
      absTime->tv_sec = max_secs;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4387
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4388
    else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4389
      absTime->tv_sec = secs;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4390
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4391
    absTime->tv_nsec = (time % 1000) * NANOSECS_PER_MILLISEC;
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
    jlong secs = time / NANOSECS_PER_SEC;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4395
    if (secs >= MAX_SECS) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4396
      absTime->tv_sec = max_secs;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4397
      absTime->tv_nsec = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4398
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4399
    else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4400
      absTime->tv_sec = now.tv_sec + secs;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4401
      absTime->tv_nsec = (time % NANOSECS_PER_SEC) + now.tv_usec*1000;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4402
      if (absTime->tv_nsec >= NANOSECS_PER_SEC) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4403
        absTime->tv_nsec -= NANOSECS_PER_SEC;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4404
        ++absTime->tv_sec; // note: this must be <= max_secs
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4405
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4406
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4407
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4408
  assert(absTime->tv_sec >= 0, "tv_sec < 0");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4409
  assert(absTime->tv_sec <= max_secs, "tv_sec > max_secs");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4410
  assert(absTime->tv_nsec >= 0, "tv_nsec < 0");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4411
  assert(absTime->tv_nsec < NANOSECS_PER_SEC, "tv_nsec >= nanos_per_sec");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4412
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4413
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4414
void Parker::park(bool isAbsolute, jlong time) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4415
  // Optional fast-path check:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4416
  // Return immediately if a permit is available.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4417
  if (_counter > 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4418
      _counter = 0 ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4419
      return ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4420
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4421
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4422
  Thread* thread = Thread::current();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4423
  assert(thread->is_Java_thread(), "Must be JavaThread");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4424
  JavaThread *jt = (JavaThread *)thread;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4425
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4426
  // Optional optimization -- avoid state transitions if there's an interrupt pending.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4427
  // Check interrupt before trying to wait
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4428
  if (Thread::is_interrupted(thread, false)) {
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
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4432
  // Next, demultiplex/decode time arguments
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4433
  timespec absTime;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4434
  if (time < 0) { // don't wait at all
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4435
    return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4436
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4437
  if (time > 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4438
    unpackTime(&absTime, isAbsolute, time);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4439
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4440
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4441
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4442
  // Enter safepoint region
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4443
  // Beware of deadlocks such as 6317397.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4444
  // The per-thread Parker:: mutex is a classic leaf-lock.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4445
  // In particular a thread must never block on the Threads_lock while
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4446
  // holding the Parker:: mutex.  If safepoints are pending both the
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4447
  // the ThreadBlockInVM() CTOR and DTOR may grab Threads_lock.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4448
  ThreadBlockInVM tbivm(jt);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4449
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4450
  // Don't wait if cannot get lock since interference arises from
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4451
  // unblocking.  Also. check interrupt before trying wait
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4452
  if (Thread::is_interrupted(thread, false) || pthread_mutex_trylock(_mutex) != 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4453
    return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4454
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4455
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4456
  int status ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4457
  if (_counter > 0)  { // no wait needed
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4458
    _counter = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4459
    status = pthread_mutex_unlock(_mutex);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4460
    assert (status == 0, "invariant") ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4461
    return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4462
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4463
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4464
#ifdef ASSERT
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4465
  // Don't catch signals while blocked; let the running threads have the signals.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4466
  // (This allows a debugger to break into the running thread.)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4467
  sigset_t oldsigs;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4468
  sigset_t* allowdebug_blocked = os::Linux::allowdebug_blocked_signals();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4469
  pthread_sigmask(SIG_BLOCK, allowdebug_blocked, &oldsigs);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4470
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4471
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4472
  OSThreadWaitState osts(thread->osthread(), false /* not Object.wait() */);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4473
  jt->set_suspend_equivalent();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4474
  // cleared by handle_special_suspend_equivalent_condition() or java_suspend_self()
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4475
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4476
  if (time == 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4477
    status = pthread_cond_wait (_cond, _mutex) ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4478
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4479
    status = os::Linux::safe_cond_timedwait (_cond, _mutex, &absTime) ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4480
    if (status != 0 && WorkAroundNPTLTimedWaitHang) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4481
      pthread_cond_destroy (_cond) ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4482
      pthread_cond_init    (_cond, NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4483
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4484
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4485
  assert_status(status == 0 || status == EINTR ||
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4486
                status == ETIME || status == ETIMEDOUT,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4487
                status, "cond_timedwait");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4488
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4489
#ifdef ASSERT
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4490
  pthread_sigmask(SIG_SETMASK, &oldsigs, NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4491
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4492
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4493
  _counter = 0 ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4494
  status = pthread_mutex_unlock(_mutex) ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4495
  assert_status(status == 0, status, "invariant") ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4496
  // If externally suspended while waiting, re-suspend
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4497
  if (jt->handle_special_suspend_equivalent_condition()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4498
    jt->java_suspend_self();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4499
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4500
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4501
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4502
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4503
void Parker::unpark() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4504
  int s, status ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4505
  status = pthread_mutex_lock(_mutex);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4506
  assert (status == 0, "invariant") ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4507
  s = _counter;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4508
  _counter = 1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4509
  if (s < 1) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4510
     if (WorkAroundNPTLTimedWaitHang) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4511
        status = pthread_cond_signal (_cond) ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4512
        assert (status == 0, "invariant") ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4513
        status = pthread_mutex_unlock(_mutex);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4514
        assert (status == 0, "invariant") ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4515
     } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4516
        status = pthread_mutex_unlock(_mutex);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4517
        assert (status == 0, "invariant") ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4518
        status = pthread_cond_signal (_cond) ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4519
        assert (status == 0, "invariant") ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4520
     }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4521
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4522
    pthread_mutex_unlock(_mutex);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4523
    assert (status == 0, "invariant") ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4524
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4525
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4526
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4527
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4528
extern char** environ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4529
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4530
#ifndef __NR_fork
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4531
#define __NR_fork IA32_ONLY(2) IA64_ONLY(not defined) AMD64_ONLY(57)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4532
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4533
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4534
#ifndef __NR_execve
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4535
#define __NR_execve IA32_ONLY(11) IA64_ONLY(1033) AMD64_ONLY(59)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4536
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4537
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4538
// Run the specified command in a separate process. Return its exit value,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4539
// or -1 on failure (e.g. can't fork a new process).
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4540
// Unlike system(), this function can be called from signal handler. It
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4541
// doesn't block SIGINT et al.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4542
int os::fork_and_exec(char* cmd) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4543
  char * argv[4];
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4544
  argv[0] = "sh";
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4545
  argv[1] = "-c";
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4546
  argv[2] = cmd;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4547
  argv[3] = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4548
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4549
  // fork() in LinuxThreads/NPTL is not async-safe. It needs to run
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4550
  // pthread_atfork handlers and reset pthread library. All we need is a
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4551
  // separate process to execve. Make a direct syscall to fork process.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4552
  // On IA64 there's no fork syscall, we have to use fork() and hope for
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4553
  // the best...
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4554
  pid_t pid = NOT_IA64(syscall(__NR_fork);)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4555
              IA64_ONLY(fork();)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4556
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4557
  if (pid < 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4558
    // fork failed
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4559
    return -1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4560
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4561
  } else if (pid == 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4562
    // child process
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4563
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4564
    // execve() in LinuxThreads will call pthread_kill_other_threads_np()
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4565
    // first to kill every thread on the thread list. Because this list is
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4566
    // not reset by fork() (see notes above), execve() will instead kill
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4567
    // every thread in the parent process. We know this is the only thread
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4568
    // in the new process, so make a system call directly.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4569
    // IA64 should use normal execve() from glibc to match the glibc fork()
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4570
    // above.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4571
    NOT_IA64(syscall(__NR_execve, "/bin/sh", argv, environ);)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4572
    IA64_ONLY(execve("/bin/sh", argv, environ);)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4573
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4574
    // execve failed
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4575
    _exit(-1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4576
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4577
  } else  {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4578
    // copied from J2SE ..._waitForProcessExit() in UNIXProcess_md.c; we don't
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4579
    // care about the actual exit code, for now.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4580
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4581
    int status;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4582
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4583
    // Wait for the child process to exit.  This returns immediately if
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4584
    // the child has already exited. */
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4585
    while (waitpid(pid, &status, 0) < 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4586
        switch (errno) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4587
        case ECHILD: return 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4588
        case EINTR: break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4589
        default: return -1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4590
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4591
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4592
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4593
    if (WIFEXITED(status)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4594
       // The child exited normally; get its exit code.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4595
       return WEXITSTATUS(status);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4596
    } else if (WIFSIGNALED(status)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4597
       // The child exited because of a signal
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4598
       // The best value to return is 0x80 + signal number,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4599
       // because that is what all Unix shells do, and because
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4600
       // it allows callers to distinguish between process exit and
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4601
       // process death by signal.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4602
       return 0x80 + WTERMSIG(status);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4603
    } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4604
       // Unknown exit code; pass it through
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4605
       return status;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4606
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4607
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4608
}