hotspot/src/share/vm/runtime/os.cpp
author trims
Thu, 12 Mar 2009 18:16:36 -0700
changeset 2154 72a9b7284ccf
parent 2105 347008ce7984
parent 2146 e1efdb8c4eca
child 2358 7c8346929fc6
permissions -rw-r--r--
Merge
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
     1
/*
2105
347008ce7984 6814575: Update copyright year
xdono
parents: 2012
diff changeset
     2
 * Copyright 1997-2009 Sun Microsystems, Inc.  All Rights Reserved.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
     3
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
489c9b5090e2 Initial load
duke
parents:
diff changeset
     4
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
     5
 * This code is free software; you can redistribute it and/or modify it
489c9b5090e2 Initial load
duke
parents:
diff changeset
     6
 * under the terms of the GNU General Public License version 2 only, as
489c9b5090e2 Initial load
duke
parents:
diff changeset
     7
 * published by the Free Software Foundation.
489c9b5090e2 Initial load
duke
parents:
diff changeset
     8
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
     9
 * This code is distributed in the hope that it will be useful, but WITHOUT
489c9b5090e2 Initial load
duke
parents:
diff changeset
    10
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
489c9b5090e2 Initial load
duke
parents:
diff changeset
    11
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
489c9b5090e2 Initial load
duke
parents:
diff changeset
    12
 * version 2 for more details (a copy is included in the LICENSE file that
489c9b5090e2 Initial load
duke
parents:
diff changeset
    13
 * accompanied this code).
489c9b5090e2 Initial load
duke
parents:
diff changeset
    14
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
    15
 * You should have received a copy of the GNU General Public License version
489c9b5090e2 Initial load
duke
parents:
diff changeset
    16
 * 2 along with this work; if not, write to the Free Software Foundation,
489c9b5090e2 Initial load
duke
parents:
diff changeset
    17
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    18
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
    19
 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
489c9b5090e2 Initial load
duke
parents:
diff changeset
    20
 * CA 95054 USA or visit www.sun.com if you need additional information or
489c9b5090e2 Initial load
duke
parents:
diff changeset
    21
 * have any questions.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    22
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
    23
 */
489c9b5090e2 Initial load
duke
parents:
diff changeset
    24
489c9b5090e2 Initial load
duke
parents:
diff changeset
    25
# include "incls/_precompiled.incl"
489c9b5090e2 Initial load
duke
parents:
diff changeset
    26
# include "incls/_os.cpp.incl"
489c9b5090e2 Initial load
duke
parents:
diff changeset
    27
489c9b5090e2 Initial load
duke
parents:
diff changeset
    28
# include <signal.h>
489c9b5090e2 Initial load
duke
parents:
diff changeset
    29
489c9b5090e2 Initial load
duke
parents:
diff changeset
    30
OSThread*         os::_starting_thread    = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    31
address           os::_polling_page       = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    32
volatile int32_t* os::_mem_serialize_page = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    33
uintptr_t         os::_serialize_page_mask = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    34
long              os::_rand_seed          = 1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    35
int               os::_processor_count    = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    36
size_t            os::_page_sizes[os::page_sizes_max];
489c9b5090e2 Initial load
duke
parents:
diff changeset
    37
489c9b5090e2 Initial load
duke
parents:
diff changeset
    38
#ifndef PRODUCT
489c9b5090e2 Initial load
duke
parents:
diff changeset
    39
int os::num_mallocs = 0;            // # of calls to malloc/realloc
489c9b5090e2 Initial load
duke
parents:
diff changeset
    40
size_t os::alloc_bytes = 0;         // # of bytes allocated
489c9b5090e2 Initial load
duke
parents:
diff changeset
    41
int os::num_frees = 0;              // # of calls to free
489c9b5090e2 Initial load
duke
parents:
diff changeset
    42
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
    43
489c9b5090e2 Initial load
duke
parents:
diff changeset
    44
// Fill in buffer with current local time as an ISO-8601 string.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    45
// E.g., yyyy-mm-ddThh:mm:ss-zzzz.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    46
// Returns buffer, or NULL if it failed.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    47
// This would mostly be a call to
489c9b5090e2 Initial load
duke
parents:
diff changeset
    48
//     strftime(...., "%Y-%m-%d" "T" "%H:%M:%S" "%z", ....)
489c9b5090e2 Initial load
duke
parents:
diff changeset
    49
// except that on Windows the %z behaves badly, so we do it ourselves.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    50
// Also, people wanted milliseconds on there,
489c9b5090e2 Initial load
duke
parents:
diff changeset
    51
// and strftime doesn't do milliseconds.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    52
char* os::iso8601_time(char* buffer, size_t buffer_length) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    53
  // Output will be of the form "YYYY-MM-DDThh:mm:ss.mmm+zzzz\0"
489c9b5090e2 Initial load
duke
parents:
diff changeset
    54
  //                                      1         2
489c9b5090e2 Initial load
duke
parents:
diff changeset
    55
  //                             12345678901234567890123456789
489c9b5090e2 Initial load
duke
parents:
diff changeset
    56
  static const char* iso8601_format =
489c9b5090e2 Initial load
duke
parents:
diff changeset
    57
    "%04d-%02d-%02dT%02d:%02d:%02d.%03d%c%02d%02d";
489c9b5090e2 Initial load
duke
parents:
diff changeset
    58
  static const size_t needed_buffer = 29;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    59
489c9b5090e2 Initial load
duke
parents:
diff changeset
    60
  // Sanity check the arguments
489c9b5090e2 Initial load
duke
parents:
diff changeset
    61
  if (buffer == NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    62
    assert(false, "NULL buffer");
489c9b5090e2 Initial load
duke
parents:
diff changeset
    63
    return NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    64
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    65
  if (buffer_length < needed_buffer) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    66
    assert(false, "buffer_length too small");
489c9b5090e2 Initial load
duke
parents:
diff changeset
    67
    return NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    68
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    69
  // Get the current time
234
4da9c1bbc810 6667833: Remove CacheTimeMillis
sbohne
parents: 228
diff changeset
    70
  jlong milliseconds_since_19700101 = javaTimeMillis();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    71
  const int milliseconds_per_microsecond = 1000;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    72
  const time_t seconds_since_19700101 =
489c9b5090e2 Initial load
duke
parents:
diff changeset
    73
    milliseconds_since_19700101 / milliseconds_per_microsecond;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    74
  const int milliseconds_after_second =
489c9b5090e2 Initial load
duke
parents:
diff changeset
    75
    milliseconds_since_19700101 % milliseconds_per_microsecond;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    76
  // Convert the time value to a tm and timezone variable
2012
041fbc6030dd 6800586: -XX:+PrintGCDateStamps is using mt-unsafe localtime function
ysr
parents: 1664
diff changeset
    77
  struct tm time_struct;
041fbc6030dd 6800586: -XX:+PrintGCDateStamps is using mt-unsafe localtime function
ysr
parents: 1664
diff changeset
    78
  if (localtime_pd(&seconds_since_19700101, &time_struct) == NULL) {
041fbc6030dd 6800586: -XX:+PrintGCDateStamps is using mt-unsafe localtime function
ysr
parents: 1664
diff changeset
    79
    assert(false, "Failed localtime_pd");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    80
    return NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    81
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    82
  const time_t zone = timezone;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    83
489c9b5090e2 Initial load
duke
parents:
diff changeset
    84
  // If daylight savings time is in effect,
489c9b5090e2 Initial load
duke
parents:
diff changeset
    85
  // we are 1 hour East of our time zone
489c9b5090e2 Initial load
duke
parents:
diff changeset
    86
  const time_t seconds_per_minute = 60;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    87
  const time_t minutes_per_hour = 60;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    88
  const time_t seconds_per_hour = seconds_per_minute * minutes_per_hour;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    89
  time_t UTC_to_local = zone;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    90
  if (time_struct.tm_isdst > 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    91
    UTC_to_local = UTC_to_local - seconds_per_hour;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    92
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    93
  // Compute the time zone offset.
2012
041fbc6030dd 6800586: -XX:+PrintGCDateStamps is using mt-unsafe localtime function
ysr
parents: 1664
diff changeset
    94
  //    localtime_pd() sets timezone to the difference (in seconds)
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    95
  //    between UTC and and local time.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    96
  //    ISO 8601 says we need the difference between local time and UTC,
2012
041fbc6030dd 6800586: -XX:+PrintGCDateStamps is using mt-unsafe localtime function
ysr
parents: 1664
diff changeset
    97
  //    we change the sign of the localtime_pd() result.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    98
  const time_t local_to_UTC = -(UTC_to_local);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    99
  // Then we have to figure out if if we are ahead (+) or behind (-) UTC.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   100
  char sign_local_to_UTC = '+';
489c9b5090e2 Initial load
duke
parents:
diff changeset
   101
  time_t abs_local_to_UTC = local_to_UTC;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   102
  if (local_to_UTC < 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   103
    sign_local_to_UTC = '-';
489c9b5090e2 Initial load
duke
parents:
diff changeset
   104
    abs_local_to_UTC = -(abs_local_to_UTC);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   105
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   106
  // Convert time zone offset seconds to hours and minutes.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   107
  const time_t zone_hours = (abs_local_to_UTC / seconds_per_hour);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   108
  const time_t zone_min =
489c9b5090e2 Initial load
duke
parents:
diff changeset
   109
    ((abs_local_to_UTC % seconds_per_hour) / seconds_per_minute);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   110
489c9b5090e2 Initial load
duke
parents:
diff changeset
   111
  // Print an ISO 8601 date and time stamp into the buffer
489c9b5090e2 Initial load
duke
parents:
diff changeset
   112
  const int year = 1900 + time_struct.tm_year;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   113
  const int month = 1 + time_struct.tm_mon;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   114
  const int printed = jio_snprintf(buffer, buffer_length, iso8601_format,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   115
                                   year,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   116
                                   month,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   117
                                   time_struct.tm_mday,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   118
                                   time_struct.tm_hour,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   119
                                   time_struct.tm_min,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   120
                                   time_struct.tm_sec,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   121
                                   milliseconds_after_second,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   122
                                   sign_local_to_UTC,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   123
                                   zone_hours,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   124
                                   zone_min);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   125
  if (printed == 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   126
    assert(false, "Failed jio_printf");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   127
    return NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   128
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   129
  return buffer;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   130
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   131
489c9b5090e2 Initial load
duke
parents:
diff changeset
   132
OSReturn os::set_priority(Thread* thread, ThreadPriority p) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   133
#ifdef ASSERT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   134
  if (!(!thread->is_Java_thread() ||
489c9b5090e2 Initial load
duke
parents:
diff changeset
   135
         Thread::current() == thread  ||
489c9b5090e2 Initial load
duke
parents:
diff changeset
   136
         Threads_lock->owned_by_self()
489c9b5090e2 Initial load
duke
parents:
diff changeset
   137
         || thread->is_Compiler_thread()
489c9b5090e2 Initial load
duke
parents:
diff changeset
   138
        )) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   139
    assert(false, "possibility of dangling Thread pointer");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   140
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   141
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
   142
489c9b5090e2 Initial load
duke
parents:
diff changeset
   143
  if (p >= MinPriority && p <= MaxPriority) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   144
    int priority = java_to_os_priority[p];
489c9b5090e2 Initial load
duke
parents:
diff changeset
   145
    return set_native_priority(thread, priority);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   146
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   147
    assert(false, "Should not happen");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   148
    return OS_ERR;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   149
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   150
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   151
489c9b5090e2 Initial load
duke
parents:
diff changeset
   152
489c9b5090e2 Initial load
duke
parents:
diff changeset
   153
OSReturn os::get_priority(const Thread* const thread, ThreadPriority& priority) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   154
  int p;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   155
  int os_prio;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   156
  OSReturn ret = get_native_priority(thread, &os_prio);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   157
  if (ret != OS_OK) return ret;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   158
489c9b5090e2 Initial load
duke
parents:
diff changeset
   159
  for (p = MaxPriority; p > MinPriority && java_to_os_priority[p] > os_prio; p--) ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   160
  priority = (ThreadPriority)p;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   161
  return OS_OK;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   162
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   163
489c9b5090e2 Initial load
duke
parents:
diff changeset
   164
489c9b5090e2 Initial load
duke
parents:
diff changeset
   165
// --------------------- sun.misc.Signal (optional) ---------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   166
489c9b5090e2 Initial load
duke
parents:
diff changeset
   167
489c9b5090e2 Initial load
duke
parents:
diff changeset
   168
// SIGBREAK is sent by the keyboard to query the VM state
489c9b5090e2 Initial load
duke
parents:
diff changeset
   169
#ifndef SIGBREAK
489c9b5090e2 Initial load
duke
parents:
diff changeset
   170
#define SIGBREAK SIGQUIT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   171
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
   172
489c9b5090e2 Initial load
duke
parents:
diff changeset
   173
// sigexitnum_pd is a platform-specific special signal used for terminating the Signal thread.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   174
489c9b5090e2 Initial load
duke
parents:
diff changeset
   175
489c9b5090e2 Initial load
duke
parents:
diff changeset
   176
static void signal_thread_entry(JavaThread* thread, TRAPS) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   177
  os::set_priority(thread, NearMaxPriority);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   178
  while (true) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   179
    int sig;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   180
    {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   181
      // FIXME : Currently we have not decieded what should be the status
489c9b5090e2 Initial load
duke
parents:
diff changeset
   182
      //         for this java thread blocked here. Once we decide about
489c9b5090e2 Initial load
duke
parents:
diff changeset
   183
      //         that we should fix this.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   184
      sig = os::signal_wait();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   185
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   186
    if (sig == os::sigexitnum_pd()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   187
       // Terminate the signal thread
489c9b5090e2 Initial load
duke
parents:
diff changeset
   188
       return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   189
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   190
489c9b5090e2 Initial load
duke
parents:
diff changeset
   191
    switch (sig) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   192
      case SIGBREAK: {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   193
        // Check if the signal is a trigger to start the Attach Listener - in that
489c9b5090e2 Initial load
duke
parents:
diff changeset
   194
        // case don't print stack traces.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   195
        if (!DisableAttachMechanism && AttachListener::is_init_trigger()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   196
          continue;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   197
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   198
        // Print stack traces
489c9b5090e2 Initial load
duke
parents:
diff changeset
   199
        // Any SIGBREAK operations added here should make sure to flush
489c9b5090e2 Initial load
duke
parents:
diff changeset
   200
        // the output stream (e.g. tty->flush()) after output.  See 4803766.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   201
        // Each module also prints an extra carriage return after its output.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   202
        VM_PrintThreads op;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   203
        VMThread::execute(&op);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   204
        VM_PrintJNI jni_op;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   205
        VMThread::execute(&jni_op);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   206
        VM_FindDeadlocks op1(tty);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   207
        VMThread::execute(&op1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   208
        Universe::print_heap_at_SIGBREAK();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   209
        if (PrintClassHistogram) {
2141
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 2012
diff changeset
   210
          VM_GC_HeapInspection op1(gclog_or_tty, true /* force full GC before heap inspection */,
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 2012
diff changeset
   211
                                   true /* need_prologue */);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   212
          VMThread::execute(&op1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   213
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   214
        if (JvmtiExport::should_post_data_dump()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   215
          JvmtiExport::post_data_dump();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   216
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   217
        break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   218
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   219
      default: {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   220
        // Dispatch the signal to java
489c9b5090e2 Initial load
duke
parents:
diff changeset
   221
        HandleMark hm(THREAD);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   222
        klassOop k = SystemDictionary::resolve_or_null(vmSymbolHandles::sun_misc_Signal(), THREAD);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   223
        KlassHandle klass (THREAD, k);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   224
        if (klass.not_null()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   225
          JavaValue result(T_VOID);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   226
          JavaCallArguments args;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   227
          args.push_int(sig);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   228
          JavaCalls::call_static(
489c9b5090e2 Initial load
duke
parents:
diff changeset
   229
            &result,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   230
            klass,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   231
            vmSymbolHandles::dispatch_name(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   232
            vmSymbolHandles::int_void_signature(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   233
            &args,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   234
            THREAD
489c9b5090e2 Initial load
duke
parents:
diff changeset
   235
          );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   236
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   237
        if (HAS_PENDING_EXCEPTION) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   238
          // tty is initialized early so we don't expect it to be null, but
489c9b5090e2 Initial load
duke
parents:
diff changeset
   239
          // if it is we can't risk doing an initialization that might
489c9b5090e2 Initial load
duke
parents:
diff changeset
   240
          // trigger additional out-of-memory conditions
489c9b5090e2 Initial load
duke
parents:
diff changeset
   241
          if (tty != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   242
            char klass_name[256];
489c9b5090e2 Initial load
duke
parents:
diff changeset
   243
            char tmp_sig_name[16];
489c9b5090e2 Initial load
duke
parents:
diff changeset
   244
            const char* sig_name = "UNKNOWN";
489c9b5090e2 Initial load
duke
parents:
diff changeset
   245
            instanceKlass::cast(PENDING_EXCEPTION->klass())->
489c9b5090e2 Initial load
duke
parents:
diff changeset
   246
              name()->as_klass_external_name(klass_name, 256);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   247
            if (os::exception_name(sig, tmp_sig_name, 16) != NULL)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   248
              sig_name = tmp_sig_name;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   249
            warning("Exception %s occurred dispatching signal %s to handler"
489c9b5090e2 Initial load
duke
parents:
diff changeset
   250
                    "- the VM may need to be forcibly terminated",
489c9b5090e2 Initial load
duke
parents:
diff changeset
   251
                    klass_name, sig_name );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   252
          }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   253
          CLEAR_PENDING_EXCEPTION;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   254
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   255
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   256
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   257
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   258
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   259
489c9b5090e2 Initial load
duke
parents:
diff changeset
   260
489c9b5090e2 Initial load
duke
parents:
diff changeset
   261
void os::signal_init() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   262
  if (!ReduceSignalUsage) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   263
    // Setup JavaThread for processing signals
489c9b5090e2 Initial load
duke
parents:
diff changeset
   264
    EXCEPTION_MARK;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   265
    klassOop k = SystemDictionary::resolve_or_fail(vmSymbolHandles::java_lang_Thread(), true, CHECK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   266
    instanceKlassHandle klass (THREAD, k);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   267
    instanceHandle thread_oop = klass->allocate_instance_handle(CHECK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   268
489c9b5090e2 Initial load
duke
parents:
diff changeset
   269
    const char thread_name[] = "Signal Dispatcher";
489c9b5090e2 Initial load
duke
parents:
diff changeset
   270
    Handle string = java_lang_String::create_from_str(thread_name, CHECK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   271
489c9b5090e2 Initial load
duke
parents:
diff changeset
   272
    // Initialize thread_oop to put it into the system threadGroup
489c9b5090e2 Initial load
duke
parents:
diff changeset
   273
    Handle thread_group (THREAD, Universe::system_thread_group());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   274
    JavaValue result(T_VOID);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   275
    JavaCalls::call_special(&result, thread_oop,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   276
                           klass,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   277
                           vmSymbolHandles::object_initializer_name(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   278
                           vmSymbolHandles::threadgroup_string_void_signature(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   279
                           thread_group,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   280
                           string,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   281
                           CHECK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   282
489c9b5090e2 Initial load
duke
parents:
diff changeset
   283
    KlassHandle group(THREAD, SystemDictionary::threadGroup_klass());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   284
    JavaCalls::call_special(&result,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   285
                            thread_group,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   286
                            group,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   287
                            vmSymbolHandles::add_method_name(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   288
                            vmSymbolHandles::thread_void_signature(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   289
                            thread_oop,         // ARG 1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   290
                            CHECK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   291
489c9b5090e2 Initial load
duke
parents:
diff changeset
   292
    os::signal_init_pd();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   293
489c9b5090e2 Initial load
duke
parents:
diff changeset
   294
    { MutexLocker mu(Threads_lock);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   295
      JavaThread* signal_thread = new JavaThread(&signal_thread_entry);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   296
489c9b5090e2 Initial load
duke
parents:
diff changeset
   297
      // At this point it may be possible that no osthread was created for the
489c9b5090e2 Initial load
duke
parents:
diff changeset
   298
      // JavaThread due to lack of memory. We would have to throw an exception
489c9b5090e2 Initial load
duke
parents:
diff changeset
   299
      // in that case. However, since this must work and we do not allow
489c9b5090e2 Initial load
duke
parents:
diff changeset
   300
      // exceptions anyway, check and abort if this fails.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   301
      if (signal_thread == NULL || signal_thread->osthread() == NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   302
        vm_exit_during_initialization("java.lang.OutOfMemoryError",
489c9b5090e2 Initial load
duke
parents:
diff changeset
   303
                                      "unable to create new native thread");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   304
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   305
489c9b5090e2 Initial load
duke
parents:
diff changeset
   306
      java_lang_Thread::set_thread(thread_oop(), signal_thread);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   307
      java_lang_Thread::set_priority(thread_oop(), NearMaxPriority);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   308
      java_lang_Thread::set_daemon(thread_oop());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   309
489c9b5090e2 Initial load
duke
parents:
diff changeset
   310
      signal_thread->set_threadObj(thread_oop());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   311
      Threads::add(signal_thread);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   312
      Thread::start(signal_thread);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   313
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   314
    // Handle ^BREAK
489c9b5090e2 Initial load
duke
parents:
diff changeset
   315
    os::signal(SIGBREAK, os::user_handler());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   316
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   317
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   318
489c9b5090e2 Initial load
duke
parents:
diff changeset
   319
489c9b5090e2 Initial load
duke
parents:
diff changeset
   320
void os::terminate_signal_thread() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   321
  if (!ReduceSignalUsage)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   322
    signal_notify(sigexitnum_pd());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   323
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   324
489c9b5090e2 Initial load
duke
parents:
diff changeset
   325
489c9b5090e2 Initial load
duke
parents:
diff changeset
   326
// --------------------- loading libraries ---------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   327
489c9b5090e2 Initial load
duke
parents:
diff changeset
   328
typedef jint (JNICALL *JNI_OnLoad_t)(JavaVM *, void *);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   329
extern struct JavaVM_ main_vm;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   330
489c9b5090e2 Initial load
duke
parents:
diff changeset
   331
static void* _native_java_library = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   332
489c9b5090e2 Initial load
duke
parents:
diff changeset
   333
void* os::native_java_library() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   334
  if (_native_java_library == NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   335
    char buffer[JVM_MAXPATHLEN];
489c9b5090e2 Initial load
duke
parents:
diff changeset
   336
    char ebuf[1024];
489c9b5090e2 Initial load
duke
parents:
diff changeset
   337
950
6112b627bb36 6721093: -XX:AppendRatio=N not supported
kamg
parents: 823
diff changeset
   338
    // Try to load verify dll first. In 1.3 java dll depends on it and is not
6112b627bb36 6721093: -XX:AppendRatio=N not supported
kamg
parents: 823
diff changeset
   339
    // always able to find it when the loading executable is outside the JDK.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   340
    // In order to keep working with 1.2 we ignore any loading errors.
950
6112b627bb36 6721093: -XX:AppendRatio=N not supported
kamg
parents: 823
diff changeset
   341
    dll_build_name(buffer, sizeof(buffer), Arguments::get_dll_dir(), "verify");
6112b627bb36 6721093: -XX:AppendRatio=N not supported
kamg
parents: 823
diff changeset
   342
    dll_load(buffer, ebuf, sizeof(ebuf));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   343
489c9b5090e2 Initial load
duke
parents:
diff changeset
   344
    // Load java dll
950
6112b627bb36 6721093: -XX:AppendRatio=N not supported
kamg
parents: 823
diff changeset
   345
    dll_build_name(buffer, sizeof(buffer), Arguments::get_dll_dir(), "java");
6112b627bb36 6721093: -XX:AppendRatio=N not supported
kamg
parents: 823
diff changeset
   346
    _native_java_library = dll_load(buffer, ebuf, sizeof(ebuf));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   347
    if (_native_java_library == NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   348
      vm_exit_during_initialization("Unable to load native library", ebuf);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   349
    }
950
6112b627bb36 6721093: -XX:AppendRatio=N not supported
kamg
parents: 823
diff changeset
   350
  }
6112b627bb36 6721093: -XX:AppendRatio=N not supported
kamg
parents: 823
diff changeset
   351
  static jboolean onLoaded = JNI_FALSE;
6112b627bb36 6721093: -XX:AppendRatio=N not supported
kamg
parents: 823
diff changeset
   352
  if (onLoaded) {
6112b627bb36 6721093: -XX:AppendRatio=N not supported
kamg
parents: 823
diff changeset
   353
    // We may have to wait to fire OnLoad until TLS is initialized.
6112b627bb36 6721093: -XX:AppendRatio=N not supported
kamg
parents: 823
diff changeset
   354
    if (ThreadLocalStorage::is_initialized()) {
6112b627bb36 6721093: -XX:AppendRatio=N not supported
kamg
parents: 823
diff changeset
   355
      // The JNI_OnLoad handling is normally done by method load in
6112b627bb36 6721093: -XX:AppendRatio=N not supported
kamg
parents: 823
diff changeset
   356
      // java.lang.ClassLoader$NativeLibrary, but the VM loads the base library
6112b627bb36 6721093: -XX:AppendRatio=N not supported
kamg
parents: 823
diff changeset
   357
      // explicitly so we have to check for JNI_OnLoad as well
6112b627bb36 6721093: -XX:AppendRatio=N not supported
kamg
parents: 823
diff changeset
   358
      const char *onLoadSymbols[] = JNI_ONLOAD_SYMBOLS;
6112b627bb36 6721093: -XX:AppendRatio=N not supported
kamg
parents: 823
diff changeset
   359
      JNI_OnLoad_t JNI_OnLoad = CAST_TO_FN_PTR(
6112b627bb36 6721093: -XX:AppendRatio=N not supported
kamg
parents: 823
diff changeset
   360
          JNI_OnLoad_t, dll_lookup(_native_java_library, onLoadSymbols[0]));
6112b627bb36 6721093: -XX:AppendRatio=N not supported
kamg
parents: 823
diff changeset
   361
      if (JNI_OnLoad != NULL) {
6112b627bb36 6721093: -XX:AppendRatio=N not supported
kamg
parents: 823
diff changeset
   362
        JavaThread* thread = JavaThread::current();
6112b627bb36 6721093: -XX:AppendRatio=N not supported
kamg
parents: 823
diff changeset
   363
        ThreadToNativeFromVM ttn(thread);
6112b627bb36 6721093: -XX:AppendRatio=N not supported
kamg
parents: 823
diff changeset
   364
        HandleMark hm(thread);
6112b627bb36 6721093: -XX:AppendRatio=N not supported
kamg
parents: 823
diff changeset
   365
        jint ver = (*JNI_OnLoad)(&main_vm, NULL);
6112b627bb36 6721093: -XX:AppendRatio=N not supported
kamg
parents: 823
diff changeset
   366
        onLoaded = JNI_TRUE;
6112b627bb36 6721093: -XX:AppendRatio=N not supported
kamg
parents: 823
diff changeset
   367
        if (!Threads::is_supported_jni_version_including_1_1(ver)) {
6112b627bb36 6721093: -XX:AppendRatio=N not supported
kamg
parents: 823
diff changeset
   368
          vm_exit_during_initialization("Unsupported JNI version");
6112b627bb36 6721093: -XX:AppendRatio=N not supported
kamg
parents: 823
diff changeset
   369
        }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   370
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   371
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   372
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   373
  return _native_java_library;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   374
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   375
489c9b5090e2 Initial load
duke
parents:
diff changeset
   376
// --------------------- heap allocation utilities ---------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   377
489c9b5090e2 Initial load
duke
parents:
diff changeset
   378
char *os::strdup(const char *str) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   379
  size_t size = strlen(str);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   380
  char *dup_str = (char *)malloc(size + 1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   381
  if (dup_str == NULL) return NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   382
  strcpy(dup_str, str);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   383
  return dup_str;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   384
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   385
489c9b5090e2 Initial load
duke
parents:
diff changeset
   386
489c9b5090e2 Initial load
duke
parents:
diff changeset
   387
489c9b5090e2 Initial load
duke
parents:
diff changeset
   388
#ifdef ASSERT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   389
#define space_before             (MallocCushion + sizeof(double))
489c9b5090e2 Initial load
duke
parents:
diff changeset
   390
#define space_after              MallocCushion
489c9b5090e2 Initial load
duke
parents:
diff changeset
   391
#define size_addr_from_base(p)   (size_t*)(p + space_before - sizeof(size_t))
489c9b5090e2 Initial load
duke
parents:
diff changeset
   392
#define size_addr_from_obj(p)    ((size_t*)p - 1)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   393
// MallocCushion: size of extra cushion allocated around objects with +UseMallocOnly
489c9b5090e2 Initial load
duke
parents:
diff changeset
   394
// NB: cannot be debug variable, because these aren't set from the command line until
489c9b5090e2 Initial load
duke
parents:
diff changeset
   395
// *after* the first few allocs already happened
489c9b5090e2 Initial load
duke
parents:
diff changeset
   396
#define MallocCushion            16
489c9b5090e2 Initial load
duke
parents:
diff changeset
   397
#else
489c9b5090e2 Initial load
duke
parents:
diff changeset
   398
#define space_before             0
489c9b5090e2 Initial load
duke
parents:
diff changeset
   399
#define space_after              0
489c9b5090e2 Initial load
duke
parents:
diff changeset
   400
#define size_addr_from_base(p)   should not use w/o ASSERT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   401
#define size_addr_from_obj(p)    should not use w/o ASSERT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   402
#define MallocCushion            0
489c9b5090e2 Initial load
duke
parents:
diff changeset
   403
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
   404
#define paranoid                 0  /* only set to 1 if you suspect checking code has bug */
489c9b5090e2 Initial load
duke
parents:
diff changeset
   405
489c9b5090e2 Initial load
duke
parents:
diff changeset
   406
#ifdef ASSERT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   407
inline size_t get_size(void* obj) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   408
  size_t size = *size_addr_from_obj(obj);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   409
  if (size < 0 )
489c9b5090e2 Initial load
duke
parents:
diff changeset
   410
    fatal2("free: size field of object #%p was overwritten (%lu)", obj, size);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   411
  return size;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   412
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   413
489c9b5090e2 Initial load
duke
parents:
diff changeset
   414
u_char* find_cushion_backwards(u_char* start) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   415
  u_char* p = start;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   416
  while (p[ 0] != badResourceValue || p[-1] != badResourceValue ||
489c9b5090e2 Initial load
duke
parents:
diff changeset
   417
         p[-2] != badResourceValue || p[-3] != badResourceValue) p--;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   418
  // ok, we have four consecutive marker bytes; find start
489c9b5090e2 Initial load
duke
parents:
diff changeset
   419
  u_char* q = p - 4;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   420
  while (*q == badResourceValue) q--;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   421
  return q + 1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   422
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   423
489c9b5090e2 Initial load
duke
parents:
diff changeset
   424
u_char* find_cushion_forwards(u_char* start) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   425
  u_char* p = start;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   426
  while (p[0] != badResourceValue || p[1] != badResourceValue ||
489c9b5090e2 Initial load
duke
parents:
diff changeset
   427
         p[2] != badResourceValue || p[3] != badResourceValue) p++;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   428
  // ok, we have four consecutive marker bytes; find end of cushion
489c9b5090e2 Initial load
duke
parents:
diff changeset
   429
  u_char* q = p + 4;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   430
  while (*q == badResourceValue) q++;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   431
  return q - MallocCushion;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   432
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   433
489c9b5090e2 Initial load
duke
parents:
diff changeset
   434
void print_neighbor_blocks(void* ptr) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   435
  // find block allocated before ptr (not entirely crash-proof)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   436
  if (MallocCushion < 4) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   437
    tty->print_cr("### cannot find previous block (MallocCushion < 4)");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   438
    return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   439
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   440
  u_char* start_of_this_block = (u_char*)ptr - space_before;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   441
  u_char* end_of_prev_block_data = start_of_this_block - space_after -1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   442
  // look for cushion in front of prev. block
489c9b5090e2 Initial load
duke
parents:
diff changeset
   443
  u_char* start_of_prev_block = find_cushion_backwards(end_of_prev_block_data);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   444
  ptrdiff_t size = *size_addr_from_base(start_of_prev_block);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   445
  u_char* obj = start_of_prev_block + space_before;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   446
  if (size <= 0 ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   447
    // start is bad; mayhave been confused by OS data inbetween objects
489c9b5090e2 Initial load
duke
parents:
diff changeset
   448
    // search one more backwards
489c9b5090e2 Initial load
duke
parents:
diff changeset
   449
    start_of_prev_block = find_cushion_backwards(start_of_prev_block);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   450
    size = *size_addr_from_base(start_of_prev_block);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   451
    obj = start_of_prev_block + space_before;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   452
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   453
489c9b5090e2 Initial load
duke
parents:
diff changeset
   454
  if (start_of_prev_block + space_before + size + space_after == start_of_this_block) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   455
    tty->print_cr("### previous object: %p (%ld bytes)", obj, size);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   456
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   457
    tty->print_cr("### previous object (not sure if correct): %p (%ld bytes)", obj, size);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   458
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   459
489c9b5090e2 Initial load
duke
parents:
diff changeset
   460
  // now find successor block
489c9b5090e2 Initial load
duke
parents:
diff changeset
   461
  u_char* start_of_next_block = (u_char*)ptr + *size_addr_from_obj(ptr) + space_after;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   462
  start_of_next_block = find_cushion_forwards(start_of_next_block);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   463
  u_char* next_obj = start_of_next_block + space_before;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   464
  ptrdiff_t next_size = *size_addr_from_base(start_of_next_block);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   465
  if (start_of_next_block[0] == badResourceValue &&
489c9b5090e2 Initial load
duke
parents:
diff changeset
   466
      start_of_next_block[1] == badResourceValue &&
489c9b5090e2 Initial load
duke
parents:
diff changeset
   467
      start_of_next_block[2] == badResourceValue &&
489c9b5090e2 Initial load
duke
parents:
diff changeset
   468
      start_of_next_block[3] == badResourceValue) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   469
    tty->print_cr("### next object: %p (%ld bytes)", next_obj, next_size);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   470
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   471
    tty->print_cr("### next object (not sure if correct): %p (%ld bytes)", next_obj, next_size);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   472
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   473
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   474
489c9b5090e2 Initial load
duke
parents:
diff changeset
   475
489c9b5090e2 Initial load
duke
parents:
diff changeset
   476
void report_heap_error(void* memblock, void* bad, const char* where) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   477
  tty->print_cr("## nof_mallocs = %d, nof_frees = %d", os::num_mallocs, os::num_frees);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   478
  tty->print_cr("## memory stomp: byte at %p %s object %p", bad, where, memblock);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   479
  print_neighbor_blocks(memblock);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   480
  fatal("memory stomping error");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   481
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   482
489c9b5090e2 Initial load
duke
parents:
diff changeset
   483
void verify_block(void* memblock) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   484
  size_t size = get_size(memblock);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   485
  if (MallocCushion) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   486
    u_char* ptr = (u_char*)memblock - space_before;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   487
    for (int i = 0; i < MallocCushion; i++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   488
      if (ptr[i] != badResourceValue) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   489
        report_heap_error(memblock, ptr+i, "in front of");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   490
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   491
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   492
    u_char* end = (u_char*)memblock + size + space_after;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   493
    for (int j = -MallocCushion; j < 0; j++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   494
      if (end[j] != badResourceValue) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   495
        report_heap_error(memblock, end+j, "after");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   496
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   497
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   498
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   499
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   500
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
   501
489c9b5090e2 Initial load
duke
parents:
diff changeset
   502
void* os::malloc(size_t size) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   503
  NOT_PRODUCT(num_mallocs++);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   504
  NOT_PRODUCT(alloc_bytes += size);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   505
489c9b5090e2 Initial load
duke
parents:
diff changeset
   506
  if (size == 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   507
    // return a valid pointer if size is zero
489c9b5090e2 Initial load
duke
parents:
diff changeset
   508
    // if NULL is returned the calling functions assume out of memory.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   509
    size = 1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   510
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   511
489c9b5090e2 Initial load
duke
parents:
diff changeset
   512
  NOT_PRODUCT(if (MallocVerifyInterval > 0) check_heap());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   513
  u_char* ptr = (u_char*)::malloc(size + space_before + space_after);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   514
#ifdef ASSERT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   515
  if (ptr == NULL) return NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   516
  if (MallocCushion) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   517
    for (u_char* p = ptr; p < ptr + MallocCushion; p++) *p = (u_char)badResourceValue;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   518
    u_char* end = ptr + space_before + size;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   519
    for (u_char* pq = ptr+MallocCushion; pq < end; pq++) *pq = (u_char)uninitBlockPad;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   520
    for (u_char* q = end; q < end + MallocCushion; q++) *q = (u_char)badResourceValue;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   521
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   522
  // put size just before data
489c9b5090e2 Initial load
duke
parents:
diff changeset
   523
  *size_addr_from_base(ptr) = size;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   524
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
   525
  u_char* memblock = ptr + space_before;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   526
  if ((intptr_t)memblock == (intptr_t)MallocCatchPtr) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   527
    tty->print_cr("os::malloc caught, %lu bytes --> %p", size, memblock);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   528
    breakpoint();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   529
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   530
  debug_only(if (paranoid) verify_block(memblock));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   531
  if (PrintMalloc && tty != NULL) tty->print_cr("os::malloc %lu bytes --> %p", size, memblock);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   532
  return memblock;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   533
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   534
489c9b5090e2 Initial load
duke
parents:
diff changeset
   535
489c9b5090e2 Initial load
duke
parents:
diff changeset
   536
void* os::realloc(void *memblock, size_t size) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   537
  NOT_PRODUCT(num_mallocs++);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   538
  NOT_PRODUCT(alloc_bytes += size);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   539
#ifndef ASSERT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   540
  return ::realloc(memblock, size);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   541
#else
489c9b5090e2 Initial load
duke
parents:
diff changeset
   542
  if (memblock == NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   543
    return os::malloc(size);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   544
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   545
  if ((intptr_t)memblock == (intptr_t)MallocCatchPtr) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   546
    tty->print_cr("os::realloc caught %p", memblock);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   547
    breakpoint();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   548
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   549
  verify_block(memblock);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   550
  NOT_PRODUCT(if (MallocVerifyInterval > 0) check_heap());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   551
  if (size == 0) return NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   552
  // always move the block
489c9b5090e2 Initial load
duke
parents:
diff changeset
   553
  void* ptr = malloc(size);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   554
  if (PrintMalloc) tty->print_cr("os::remalloc %lu bytes, %p --> %p", size, memblock, ptr);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   555
  // Copy to new memory if malloc didn't fail
489c9b5090e2 Initial load
duke
parents:
diff changeset
   556
  if ( ptr != NULL ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   557
    memcpy(ptr, memblock, MIN2(size, get_size(memblock)));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   558
    if (paranoid) verify_block(ptr);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   559
    if ((intptr_t)ptr == (intptr_t)MallocCatchPtr) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   560
      tty->print_cr("os::realloc caught, %lu bytes --> %p", size, ptr);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   561
      breakpoint();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   562
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   563
    free(memblock);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   564
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   565
  return ptr;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   566
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
   567
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   568
489c9b5090e2 Initial load
duke
parents:
diff changeset
   569
489c9b5090e2 Initial load
duke
parents:
diff changeset
   570
void  os::free(void *memblock) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   571
  NOT_PRODUCT(num_frees++);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   572
#ifdef ASSERT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   573
  if (memblock == NULL) return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   574
  if ((intptr_t)memblock == (intptr_t)MallocCatchPtr) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   575
    if (tty != NULL) tty->print_cr("os::free caught %p", memblock);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   576
    breakpoint();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   577
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   578
  verify_block(memblock);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   579
  if (PrintMalloc && tty != NULL)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   580
    // tty->print_cr("os::free %p", memblock);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   581
    fprintf(stderr, "os::free %p\n", memblock);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   582
  NOT_PRODUCT(if (MallocVerifyInterval > 0) check_heap());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   583
  // Added by detlefs.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   584
  if (MallocCushion) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   585
    u_char* ptr = (u_char*)memblock - space_before;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   586
    for (u_char* p = ptr; p < ptr + MallocCushion; p++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   587
      guarantee(*p == badResourceValue,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   588
                "Thing freed should be malloc result.");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   589
      *p = (u_char)freeBlockPad;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   590
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   591
    size_t size = get_size(memblock);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   592
    u_char* end = ptr + space_before + size;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   593
    for (u_char* q = end; q < end + MallocCushion; q++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   594
      guarantee(*q == badResourceValue,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   595
                "Thing freed should be malloc result.");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   596
      *q = (u_char)freeBlockPad;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   597
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   598
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   599
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
   600
  ::free((char*)memblock - space_before);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   601
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   602
489c9b5090e2 Initial load
duke
parents:
diff changeset
   603
void os::init_random(long initval) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   604
  _rand_seed = initval;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   605
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   606
489c9b5090e2 Initial load
duke
parents:
diff changeset
   607
489c9b5090e2 Initial load
duke
parents:
diff changeset
   608
long os::random() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   609
  /* standard, well-known linear congruential random generator with
489c9b5090e2 Initial load
duke
parents:
diff changeset
   610
   * next_rand = (16807*seed) mod (2**31-1)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   611
   * see
489c9b5090e2 Initial load
duke
parents:
diff changeset
   612
   * (1) "Random Number Generators: Good Ones Are Hard to Find",
489c9b5090e2 Initial load
duke
parents:
diff changeset
   613
   *      S.K. Park and K.W. Miller, Communications of the ACM 31:10 (Oct 1988),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   614
   * (2) "Two Fast Implementations of the 'Minimal Standard' Random
489c9b5090e2 Initial load
duke
parents:
diff changeset
   615
   *     Number Generator", David G. Carta, Comm. ACM 33, 1 (Jan 1990), pp. 87-88.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   616
  */
489c9b5090e2 Initial load
duke
parents:
diff changeset
   617
  const long a = 16807;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   618
  const unsigned long m = 2147483647;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   619
  const long q = m / a;        assert(q == 127773, "weird math");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   620
  const long r = m % a;        assert(r == 2836, "weird math");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   621
489c9b5090e2 Initial load
duke
parents:
diff changeset
   622
  // compute az=2^31p+q
489c9b5090e2 Initial load
duke
parents:
diff changeset
   623
  unsigned long lo = a * (long)(_rand_seed & 0xFFFF);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   624
  unsigned long hi = a * (long)((unsigned long)_rand_seed >> 16);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   625
  lo += (hi & 0x7FFF) << 16;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   626
489c9b5090e2 Initial load
duke
parents:
diff changeset
   627
  // if q overflowed, ignore the overflow and increment q
489c9b5090e2 Initial load
duke
parents:
diff changeset
   628
  if (lo > m) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   629
    lo &= m;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   630
    ++lo;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   631
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   632
  lo += hi >> 15;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   633
489c9b5090e2 Initial load
duke
parents:
diff changeset
   634
  // if (p+q) overflowed, ignore the overflow and increment (p+q)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   635
  if (lo > m) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   636
    lo &= m;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   637
    ++lo;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   638
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   639
  return (_rand_seed = lo);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   640
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   641
489c9b5090e2 Initial load
duke
parents:
diff changeset
   642
// The INITIALIZED state is distinguished from the SUSPENDED state because the
489c9b5090e2 Initial load
duke
parents:
diff changeset
   643
// conditions in which a thread is first started are different from those in which
489c9b5090e2 Initial load
duke
parents:
diff changeset
   644
// a suspension is resumed.  These differences make it hard for us to apply the
489c9b5090e2 Initial load
duke
parents:
diff changeset
   645
// tougher checks when starting threads that we want to do when resuming them.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   646
// However, when start_thread is called as a result of Thread.start, on a Java
489c9b5090e2 Initial load
duke
parents:
diff changeset
   647
// thread, the operation is synchronized on the Java Thread object.  So there
489c9b5090e2 Initial load
duke
parents:
diff changeset
   648
// cannot be a race to start the thread and hence for the thread to exit while
489c9b5090e2 Initial load
duke
parents:
diff changeset
   649
// we are working on it.  Non-Java threads that start Java threads either have
489c9b5090e2 Initial load
duke
parents:
diff changeset
   650
// to do so in a context in which races are impossible, or should do appropriate
489c9b5090e2 Initial load
duke
parents:
diff changeset
   651
// locking.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   652
489c9b5090e2 Initial load
duke
parents:
diff changeset
   653
void os::start_thread(Thread* thread) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   654
  // guard suspend/resume
489c9b5090e2 Initial load
duke
parents:
diff changeset
   655
  MutexLockerEx ml(thread->SR_lock(), Mutex::_no_safepoint_check_flag);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   656
  OSThread* osthread = thread->osthread();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   657
  osthread->set_state(RUNNABLE);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   658
  pd_start_thread(thread);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   659
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   660
489c9b5090e2 Initial load
duke
parents:
diff changeset
   661
//---------------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   662
// Helper functions for fatal error handler
489c9b5090e2 Initial load
duke
parents:
diff changeset
   663
489c9b5090e2 Initial load
duke
parents:
diff changeset
   664
void os::print_hex_dump(outputStream* st, address start, address end, int unitsize) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   665
  assert(unitsize == 1 || unitsize == 2 || unitsize == 4 || unitsize == 8, "just checking");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   666
489c9b5090e2 Initial load
duke
parents:
diff changeset
   667
  int cols = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   668
  int cols_per_line = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   669
  switch (unitsize) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   670
    case 1: cols_per_line = 16; break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   671
    case 2: cols_per_line = 8;  break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   672
    case 4: cols_per_line = 4;  break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   673
    case 8: cols_per_line = 2;  break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   674
    default: return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   675
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   676
489c9b5090e2 Initial load
duke
parents:
diff changeset
   677
  address p = start;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   678
  st->print(PTR_FORMAT ":   ", start);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   679
  while (p < end) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   680
    switch (unitsize) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   681
      case 1: st->print("%02x", *(u1*)p); break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   682
      case 2: st->print("%04x", *(u2*)p); break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   683
      case 4: st->print("%08x", *(u4*)p); break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   684
      case 8: st->print("%016" FORMAT64_MODIFIER "x", *(u8*)p); break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   685
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   686
    p += unitsize;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   687
    cols++;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   688
    if (cols >= cols_per_line && p < end) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   689
       cols = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   690
       st->cr();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   691
       st->print(PTR_FORMAT ":   ", p);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   692
    } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   693
       st->print(" ");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   694
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   695
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   696
  st->cr();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   697
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   698
489c9b5090e2 Initial load
duke
parents:
diff changeset
   699
void os::print_environment_variables(outputStream* st, const char** env_list,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   700
                                     char* buffer, int len) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   701
  if (env_list) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   702
    st->print_cr("Environment Variables:");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   703
489c9b5090e2 Initial load
duke
parents:
diff changeset
   704
    for (int i = 0; env_list[i] != NULL; i++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   705
      if (getenv(env_list[i], buffer, len)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   706
        st->print(env_list[i]);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   707
        st->print("=");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   708
        st->print_cr(buffer);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   709
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   710
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   711
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   712
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   713
489c9b5090e2 Initial load
duke
parents:
diff changeset
   714
void os::print_cpu_info(outputStream* st) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   715
  // cpu
489c9b5090e2 Initial load
duke
parents:
diff changeset
   716
  st->print("CPU:");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   717
  st->print("total %d", os::processor_count());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   718
  // It's not safe to query number of active processors after crash
489c9b5090e2 Initial load
duke
parents:
diff changeset
   719
  // st->print("(active %d)", os::active_processor_count());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   720
  st->print(" %s", VM_Version::cpu_features());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   721
  st->cr();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   722
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   723
489c9b5090e2 Initial load
duke
parents:
diff changeset
   724
void os::print_date_and_time(outputStream *st) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   725
  time_t tloc;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   726
  (void)time(&tloc);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   727
  st->print("time: %s", ctime(&tloc));  // ctime adds newline.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   728
489c9b5090e2 Initial load
duke
parents:
diff changeset
   729
  double t = os::elapsedTime();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   730
  // NOTE: It tends to crash after a SEGV if we want to printf("%f",...) in
489c9b5090e2 Initial load
duke
parents:
diff changeset
   731
  //       Linux. Must be a bug in glibc ? Workaround is to round "t" to int
489c9b5090e2 Initial load
duke
parents:
diff changeset
   732
  //       before printf. We lost some precision, but who cares?
489c9b5090e2 Initial load
duke
parents:
diff changeset
   733
  st->print_cr("elapsed time: %d seconds", (int)t);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   734
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   735
489c9b5090e2 Initial load
duke
parents:
diff changeset
   736
489c9b5090e2 Initial load
duke
parents:
diff changeset
   737
// Looks like all platforms except IA64 can use the same function to check
489c9b5090e2 Initial load
duke
parents:
diff changeset
   738
// if C stack is walkable beyond current frame. The check for fp() is not
489c9b5090e2 Initial load
duke
parents:
diff changeset
   739
// necessary on Sparc, but it's harmless.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   740
bool os::is_first_C_frame(frame* fr) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   741
#ifdef IA64
489c9b5090e2 Initial load
duke
parents:
diff changeset
   742
  // In order to walk native frames on Itanium, we need to access the unwind
489c9b5090e2 Initial load
duke
parents:
diff changeset
   743
  // table, which is inside ELF. We don't want to parse ELF after fatal error,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   744
  // so return true for IA64. If we need to support C stack walking on IA64,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   745
  // this function needs to be moved to CPU specific files, as fp() on IA64
489c9b5090e2 Initial load
duke
parents:
diff changeset
   746
  // is register stack, which grows towards higher memory address.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   747
  return true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   748
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
   749
489c9b5090e2 Initial load
duke
parents:
diff changeset
   750
  // Load up sp, fp, sender sp and sender fp, check for reasonable values.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   751
  // Check usp first, because if that's bad the other accessors may fault
489c9b5090e2 Initial load
duke
parents:
diff changeset
   752
  // on some architectures.  Ditto ufp second, etc.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   753
  uintptr_t fp_align_mask = (uintptr_t)(sizeof(address)-1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   754
  // sp on amd can be 32 bit aligned.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   755
  uintptr_t sp_align_mask = (uintptr_t)(sizeof(int)-1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   756
489c9b5090e2 Initial load
duke
parents:
diff changeset
   757
  uintptr_t usp    = (uintptr_t)fr->sp();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   758
  if ((usp & sp_align_mask) != 0) return true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   759
489c9b5090e2 Initial load
duke
parents:
diff changeset
   760
  uintptr_t ufp    = (uintptr_t)fr->fp();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   761
  if ((ufp & fp_align_mask) != 0) return true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   762
489c9b5090e2 Initial load
duke
parents:
diff changeset
   763
  uintptr_t old_sp = (uintptr_t)fr->sender_sp();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   764
  if ((old_sp & sp_align_mask) != 0) return true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   765
  if (old_sp == 0 || old_sp == (uintptr_t)-1) return true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   766
489c9b5090e2 Initial load
duke
parents:
diff changeset
   767
  uintptr_t old_fp = (uintptr_t)fr->link();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   768
  if ((old_fp & fp_align_mask) != 0) return true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   769
  if (old_fp == 0 || old_fp == (uintptr_t)-1 || old_fp == ufp) return true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   770
489c9b5090e2 Initial load
duke
parents:
diff changeset
   771
  // stack grows downwards; if old_fp is below current fp or if the stack
489c9b5090e2 Initial load
duke
parents:
diff changeset
   772
  // frame is too large, either the stack is corrupted or fp is not saved
489c9b5090e2 Initial load
duke
parents:
diff changeset
   773
  // on stack (i.e. on x86, ebp may be used as general register). The stack
489c9b5090e2 Initial load
duke
parents:
diff changeset
   774
  // is not walkable beyond current frame.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   775
  if (old_fp < ufp) return true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   776
  if (old_fp - ufp > 64 * K) return true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   777
489c9b5090e2 Initial load
duke
parents:
diff changeset
   778
  return false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   779
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   780
489c9b5090e2 Initial load
duke
parents:
diff changeset
   781
#ifdef ASSERT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   782
extern "C" void test_random() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   783
  const double m = 2147483647;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   784
  double mean = 0.0, variance = 0.0, t;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   785
  long reps = 10000;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   786
  unsigned long seed = 1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   787
489c9b5090e2 Initial load
duke
parents:
diff changeset
   788
  tty->print_cr("seed %ld for %ld repeats...", seed, reps);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   789
  os::init_random(seed);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   790
  long num;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   791
  for (int k = 0; k < reps; k++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   792
    num = os::random();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   793
    double u = (double)num / m;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   794
    assert(u >= 0.0 && u <= 1.0, "bad random number!");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   795
489c9b5090e2 Initial load
duke
parents:
diff changeset
   796
    // calculate mean and variance of the random sequence
489c9b5090e2 Initial load
duke
parents:
diff changeset
   797
    mean += u;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   798
    variance += (u*u);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   799
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   800
  mean /= reps;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   801
  variance /= (reps - 1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   802
489c9b5090e2 Initial load
duke
parents:
diff changeset
   803
  assert(num == 1043618065, "bad seed");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   804
  tty->print_cr("mean of the 1st 10000 numbers: %f", mean);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   805
  tty->print_cr("variance of the 1st 10000 numbers: %f", variance);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   806
  const double eps = 0.0001;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   807
  t = fabsd(mean - 0.5018);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   808
  assert(t < eps, "bad mean");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   809
  t = (variance - 0.3355) < 0.0 ? -(variance - 0.3355) : variance - 0.3355;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   810
  assert(t < eps, "bad variance");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   811
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   812
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
   813
489c9b5090e2 Initial load
duke
parents:
diff changeset
   814
489c9b5090e2 Initial load
duke
parents:
diff changeset
   815
// Set up the boot classpath.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   816
489c9b5090e2 Initial load
duke
parents:
diff changeset
   817
char* os::format_boot_path(const char* format_string,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   818
                           const char* home,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   819
                           int home_len,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   820
                           char fileSep,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   821
                           char pathSep) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   822
    assert((fileSep == '/' && pathSep == ':') ||
489c9b5090e2 Initial load
duke
parents:
diff changeset
   823
           (fileSep == '\\' && pathSep == ';'), "unexpected seperator chars");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   824
489c9b5090e2 Initial load
duke
parents:
diff changeset
   825
    // Scan the format string to determine the length of the actual
489c9b5090e2 Initial load
duke
parents:
diff changeset
   826
    // boot classpath, and handle platform dependencies as well.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   827
    int formatted_path_len = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   828
    const char* p;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   829
    for (p = format_string; *p != 0; ++p) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   830
        if (*p == '%') formatted_path_len += home_len - 1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   831
        ++formatted_path_len;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   832
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   833
489c9b5090e2 Initial load
duke
parents:
diff changeset
   834
    char* formatted_path = NEW_C_HEAP_ARRAY(char, formatted_path_len + 1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   835
    if (formatted_path == NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   836
        return NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   837
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   838
489c9b5090e2 Initial load
duke
parents:
diff changeset
   839
    // Create boot classpath from format, substituting separator chars and
489c9b5090e2 Initial load
duke
parents:
diff changeset
   840
    // java home directory.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   841
    char* q = formatted_path;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   842
    for (p = format_string; *p != 0; ++p) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   843
        switch (*p) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   844
        case '%':
489c9b5090e2 Initial load
duke
parents:
diff changeset
   845
            strcpy(q, home);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   846
            q += home_len;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   847
            break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   848
        case '/':
489c9b5090e2 Initial load
duke
parents:
diff changeset
   849
            *q++ = fileSep;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   850
            break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   851
        case ':':
489c9b5090e2 Initial load
duke
parents:
diff changeset
   852
            *q++ = pathSep;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   853
            break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   854
        default:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   855
            *q++ = *p;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   856
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   857
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   858
    *q = '\0';
489c9b5090e2 Initial load
duke
parents:
diff changeset
   859
489c9b5090e2 Initial load
duke
parents:
diff changeset
   860
    assert((q - formatted_path) == formatted_path_len, "formatted_path size botched");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   861
    return formatted_path;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   862
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   863
489c9b5090e2 Initial load
duke
parents:
diff changeset
   864
489c9b5090e2 Initial load
duke
parents:
diff changeset
   865
bool os::set_boot_path(char fileSep, char pathSep) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   866
489c9b5090e2 Initial load
duke
parents:
diff changeset
   867
    const char* home = Arguments::get_java_home();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   868
    int home_len = (int)strlen(home);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   869
489c9b5090e2 Initial load
duke
parents:
diff changeset
   870
    static const char* meta_index_dir_format = "%/lib/";
489c9b5090e2 Initial load
duke
parents:
diff changeset
   871
    static const char* meta_index_format = "%/lib/meta-index";
489c9b5090e2 Initial load
duke
parents:
diff changeset
   872
    char* meta_index = format_boot_path(meta_index_format, home, home_len, fileSep, pathSep);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   873
    if (meta_index == NULL) return false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   874
    char* meta_index_dir = format_boot_path(meta_index_dir_format, home, home_len, fileSep, pathSep);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   875
    if (meta_index_dir == NULL) return false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   876
    Arguments::set_meta_index_path(meta_index, meta_index_dir);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   877
489c9b5090e2 Initial load
duke
parents:
diff changeset
   878
    // Any modification to the JAR-file list, for the boot classpath must be
489c9b5090e2 Initial load
duke
parents:
diff changeset
   879
    // aligned with install/install/make/common/Pack.gmk. Note: boot class
489c9b5090e2 Initial load
duke
parents:
diff changeset
   880
    // path class JARs, are stripped for StackMapTable to reduce download size.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   881
    static const char classpath_format[] =
489c9b5090e2 Initial load
duke
parents:
diff changeset
   882
        "%/lib/resources.jar:"
489c9b5090e2 Initial load
duke
parents:
diff changeset
   883
        "%/lib/rt.jar:"
489c9b5090e2 Initial load
duke
parents:
diff changeset
   884
        "%/lib/sunrsasign.jar:"
489c9b5090e2 Initial load
duke
parents:
diff changeset
   885
        "%/lib/jsse.jar:"
489c9b5090e2 Initial load
duke
parents:
diff changeset
   886
        "%/lib/jce.jar:"
489c9b5090e2 Initial load
duke
parents:
diff changeset
   887
        "%/lib/charsets.jar:"
489c9b5090e2 Initial load
duke
parents:
diff changeset
   888
        "%/classes";
489c9b5090e2 Initial load
duke
parents:
diff changeset
   889
    char* sysclasspath = format_boot_path(classpath_format, home, home_len, fileSep, pathSep);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   890
    if (sysclasspath == NULL) return false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   891
    Arguments::set_sysclasspath(sysclasspath);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   892
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
void os::set_memory_serialize_page(address page) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   897
  int count = log2_intptr(sizeof(class JavaThread)) - log2_intptr(64);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   898
  _mem_serialize_page = (volatile int32_t *)page;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   899
  // We initialize the serialization page shift count here
489c9b5090e2 Initial load
duke
parents:
diff changeset
   900
  // We assume a cache line size of 64 bytes
489c9b5090e2 Initial load
duke
parents:
diff changeset
   901
  assert(SerializePageShiftCount == count,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   902
         "thread size changed, fix SerializePageShiftCount constant");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   903
  set_serialize_page_mask((uintptr_t)(vm_page_size() - sizeof(int32_t)));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   904
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   905
228
69939fa91efd 6610420: Debug VM crashes during monitor lock rank checking
xlu
parents: 1
diff changeset
   906
static volatile intptr_t SerializePageLock = 0;
69939fa91efd 6610420: Debug VM crashes during monitor lock rank checking
xlu
parents: 1
diff changeset
   907
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   908
// This method is called from signal handler when SIGSEGV occurs while the current
489c9b5090e2 Initial load
duke
parents:
diff changeset
   909
// thread tries to store to the "read-only" memory serialize page during state
489c9b5090e2 Initial load
duke
parents:
diff changeset
   910
// transition.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   911
void os::block_on_serialize_page_trap() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   912
  if (TraceSafepoint) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   913
    tty->print_cr("Block until the serialize page permission restored");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   914
  }
228
69939fa91efd 6610420: Debug VM crashes during monitor lock rank checking
xlu
parents: 1
diff changeset
   915
  // When VMThread is holding the SerializePageLock during modifying the
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   916
  // access permission of the memory serialize page, the following call
489c9b5090e2 Initial load
duke
parents:
diff changeset
   917
  // will block until the permission of that page is restored to rw.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   918
  // Generally, it is unsafe to manipulate locks in signal handlers, but in
489c9b5090e2 Initial load
duke
parents:
diff changeset
   919
  // this case, it's OK as the signal is synchronous and we know precisely when
228
69939fa91efd 6610420: Debug VM crashes during monitor lock rank checking
xlu
parents: 1
diff changeset
   920
  // it can occur.
69939fa91efd 6610420: Debug VM crashes during monitor lock rank checking
xlu
parents: 1
diff changeset
   921
  Thread::muxAcquire(&SerializePageLock, "set_memory_serialize_page");
69939fa91efd 6610420: Debug VM crashes during monitor lock rank checking
xlu
parents: 1
diff changeset
   922
  Thread::muxRelease(&SerializePageLock);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   923
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   924
489c9b5090e2 Initial load
duke
parents:
diff changeset
   925
// Serialize all thread state variables
489c9b5090e2 Initial load
duke
parents:
diff changeset
   926
void os::serialize_thread_states() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   927
  // On some platforms such as Solaris & Linux, the time duration of the page
489c9b5090e2 Initial load
duke
parents:
diff changeset
   928
  // permission restoration is observed to be much longer than expected  due to
489c9b5090e2 Initial load
duke
parents:
diff changeset
   929
  // scheduler starvation problem etc. To avoid the long synchronization
228
69939fa91efd 6610420: Debug VM crashes during monitor lock rank checking
xlu
parents: 1
diff changeset
   930
  // time and expensive page trap spinning, 'SerializePageLock' is used to block
69939fa91efd 6610420: Debug VM crashes during monitor lock rank checking
xlu
parents: 1
diff changeset
   931
  // the mutator thread if such case is encountered. See bug 6546278 for details.
69939fa91efd 6610420: Debug VM crashes during monitor lock rank checking
xlu
parents: 1
diff changeset
   932
  Thread::muxAcquire(&SerializePageLock, "serialize_thread_states");
823
9a5271881bc0 6716785: implicit null checks not triggering with CompressedOops
coleenp
parents: 670
diff changeset
   933
  os::protect_memory((char *)os::get_memory_serialize_page(),
1664
fc9ed50498fb 6727377: VM stack guard pages on Windows should PAGE_READWRITE not PAGE_EXECUTE_READWRITE
coleenp
parents: 950
diff changeset
   934
                     os::vm_page_size(), MEM_PROT_READ);
fc9ed50498fb 6727377: VM stack guard pages on Windows should PAGE_READWRITE not PAGE_EXECUTE_READWRITE
coleenp
parents: 950
diff changeset
   935
  os::protect_memory((char *)os::get_memory_serialize_page(),
fc9ed50498fb 6727377: VM stack guard pages on Windows should PAGE_READWRITE not PAGE_EXECUTE_READWRITE
coleenp
parents: 950
diff changeset
   936
                     os::vm_page_size(), MEM_PROT_RW);
228
69939fa91efd 6610420: Debug VM crashes during monitor lock rank checking
xlu
parents: 1
diff changeset
   937
  Thread::muxRelease(&SerializePageLock);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   938
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   939
489c9b5090e2 Initial load
duke
parents:
diff changeset
   940
// Returns true if the current stack pointer is above the stack shadow
489c9b5090e2 Initial load
duke
parents:
diff changeset
   941
// pages, false otherwise.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   942
489c9b5090e2 Initial load
duke
parents:
diff changeset
   943
bool os::stack_shadow_pages_available(Thread *thread, methodHandle method) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   944
  assert(StackRedPages > 0 && StackYellowPages > 0,"Sanity check");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   945
  address sp = current_stack_pointer();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   946
  // Check if we have StackShadowPages above the yellow zone.  This parameter
2131
98f9cef66a34 6810672: Comment typos
twisti
parents: 2012
diff changeset
   947
  // is dependent on the depth of the maximum VM call stack possible from
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   948
  // the handler for stack overflow.  'instanceof' in the stack overflow
489c9b5090e2 Initial load
duke
parents:
diff changeset
   949
  // handler or a println uses at least 8k stack of VM and native code
489c9b5090e2 Initial load
duke
parents:
diff changeset
   950
  // respectively.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   951
  const int framesize_in_bytes =
489c9b5090e2 Initial load
duke
parents:
diff changeset
   952
    Interpreter::size_top_interpreter_activation(method()) * wordSize;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   953
  int reserved_area = ((StackShadowPages + StackRedPages + StackYellowPages)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   954
                      * vm_page_size()) + framesize_in_bytes;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   955
  // The very lower end of the stack
489c9b5090e2 Initial load
duke
parents:
diff changeset
   956
  address stack_limit = thread->stack_base() - thread->stack_size();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   957
  return (sp > (stack_limit + reserved_area));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   958
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   959
489c9b5090e2 Initial load
duke
parents:
diff changeset
   960
size_t os::page_size_for_region(size_t region_min_size, size_t region_max_size,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   961
                                uint min_pages)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   962
{
489c9b5090e2 Initial load
duke
parents:
diff changeset
   963
  assert(min_pages > 0, "sanity");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   964
  if (UseLargePages) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   965
    const size_t max_page_size = region_max_size / min_pages;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   966
489c9b5090e2 Initial load
duke
parents:
diff changeset
   967
    for (unsigned int i = 0; _page_sizes[i] != 0; ++i) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   968
      const size_t sz = _page_sizes[i];
489c9b5090e2 Initial load
duke
parents:
diff changeset
   969
      const size_t mask = sz - 1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   970
      if ((region_min_size & mask) == 0 && (region_max_size & mask) == 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   971
        // The largest page size with no fragmentation.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   972
        return sz;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   973
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   974
489c9b5090e2 Initial load
duke
parents:
diff changeset
   975
      if (sz <= max_page_size) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   976
        // The largest page size that satisfies the min_pages requirement.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   977
        return sz;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   978
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   979
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   980
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   981
489c9b5090e2 Initial load
duke
parents:
diff changeset
   982
  return vm_page_size();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   983
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   984
489c9b5090e2 Initial load
duke
parents:
diff changeset
   985
#ifndef PRODUCT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   986
void os::trace_page_sizes(const char* str, const size_t region_min_size,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   987
                          const size_t region_max_size, const size_t page_size,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   988
                          const char* base, const size_t size)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   989
{
489c9b5090e2 Initial load
duke
parents:
diff changeset
   990
  if (TracePageSizes) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   991
    tty->print_cr("%s:  min=" SIZE_FORMAT " max=" SIZE_FORMAT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   992
                  " pg_sz=" SIZE_FORMAT " base=" PTR_FORMAT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   993
                  " size=" SIZE_FORMAT,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   994
                  str, region_min_size, region_max_size,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   995
                  page_size, base, size);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   996
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   997
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   998
#endif  // #ifndef PRODUCT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   999
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1000
// This is the working definition of a server class machine:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1001
// >= 2 physical CPU's and >=2GB of memory, with some fuzz
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1002
// because the graphics memory (?) sometimes masks physical memory.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1003
// If you want to change the definition of a server class machine
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1004
// on some OS or platform, e.g., >=4GB on Windohs platforms,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1005
// then you'll have to parameterize this method based on that state,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1006
// as was done for logical processors here, or replicate and
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1007
// specialize this method for each platform.  (Or fix os to have
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1008
// some inheritance structure and use subclassing.  Sigh.)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1009
// If you want some platform to always or never behave as a server
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1010
// class machine, change the setting of AlwaysActAsServerClassMachine
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1011
// and NeverActAsServerClassMachine in globals*.hpp.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1012
bool os::is_server_class_machine() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1013
  // First check for the early returns
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1014
  if (NeverActAsServerClassMachine) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1015
    return false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1016
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1017
  if (AlwaysActAsServerClassMachine) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1018
    return true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1019
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1020
  // Then actually look at the machine
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1021
  bool         result            = false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1022
  const unsigned int    server_processors = 2;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1023
  const julong server_memory     = 2UL * G;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1024
  // We seem not to get our full complement of memory.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1025
  //     We allow some part (1/8?) of the memory to be "missing",
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1026
  //     based on the sizes of DIMMs, and maybe graphics cards.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1027
  const julong missing_memory   = 256UL * M;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1028
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1029
  /* Is this a server class machine? */
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1030
  if ((os::active_processor_count() >= (int)server_processors) &&
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1031
      (os::physical_memory() >= (server_memory - missing_memory))) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1032
    const unsigned int logical_processors =
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1033
      VM_Version::logical_processors_per_package();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1034
    if (logical_processors > 1) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1035
      const unsigned int physical_packages =
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1036
        os::active_processor_count() / logical_processors;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1037
      if (physical_packages > server_processors) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1038
        result = true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1039
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1040
    } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1041
      result = true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1042
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1043
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1044
  return result;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1045
}