Mercurial > hg > truffle
annotate src/share/vm/runtime/os.cpp @ 10292:acac2b03a07f
8014765: VM exits if MaxTenuringThreshold is set below the default InitialTenuringThreshold, and InitialTenuringThreshold is not set
Summary: The VM exits when the condition in the subject line applies. The fix sets InitialTenuringThreshold to MaxTenuringThreshold if it is larger than MaxTenuringThreshold and InitialTenuringThreshold has not been set (is default).
Reviewed-by: jwilhelm, jmasa, brutisso, johnc
| author | tschatzl |
|---|---|
| date | Thu, 16 May 2013 23:51:51 +0200 |
| parents | c18152e0554e |
| children | f2110083203d |
| rev | line source |
|---|---|
| 0 | 1 /* |
|
8802
eca90b8a06eb
7030610: runtime/6878713/Test6878713.sh fails Error. failed to clean up files after test
rdurbin
parents:
7994
diff
changeset
|
2 * Copyright (c) 1997, 2013, Oracle and/or its affiliates. All rights reserved. |
| 0 | 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
| 4 * | |
| 5 * This code is free software; you can redistribute it and/or modify it | |
| 6 * under the terms of the GNU General Public License version 2 only, as | |
| 7 * published by the Free Software Foundation. | |
| 8 * | |
| 9 * This code is distributed in the hope that it will be useful, but WITHOUT | |
| 10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
| 11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
| 12 * version 2 for more details (a copy is included in the LICENSE file that | |
| 13 * accompanied this code). | |
| 14 * | |
| 15 * You should have received a copy of the GNU General Public License version | |
| 16 * 2 along with this work; if not, write to the Free Software Foundation, | |
| 17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. | |
| 18 * | |
|
1552
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1490
diff
changeset
|
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1490
diff
changeset
|
20 * or visit www.oracle.com if you need additional information or have any |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1490
diff
changeset
|
21 * questions. |
| 0 | 22 * |
| 23 */ | |
| 24 | |
| 1972 | 25 #include "precompiled.hpp" |
| 26 #include "classfile/classLoader.hpp" | |
| 27 #include "classfile/javaClasses.hpp" | |
| 28 #include "classfile/systemDictionary.hpp" | |
| 29 #include "classfile/vmSymbols.hpp" | |
| 30 #include "code/icBuffer.hpp" | |
| 31 #include "code/vtableStubs.hpp" | |
| 32 #include "gc_implementation/shared/vmGCOperations.hpp" | |
| 33 #include "interpreter/interpreter.hpp" | |
| 34 #include "memory/allocation.inline.hpp" | |
| 35 #include "oops/oop.inline.hpp" | |
| 36 #include "prims/jvm.h" | |
| 37 #include "prims/jvm_misc.hpp" | |
| 38 #include "prims/privilegedStack.hpp" | |
| 39 #include "runtime/arguments.hpp" | |
| 40 #include "runtime/frame.inline.hpp" | |
| 41 #include "runtime/interfaceSupport.hpp" | |
| 42 #include "runtime/java.hpp" | |
| 43 #include "runtime/javaCalls.hpp" | |
| 44 #include "runtime/mutexLocker.hpp" | |
| 45 #include "runtime/os.hpp" | |
| 46 #include "runtime/stubRoutines.hpp" | |
|
7180
f34d701e952e
8003935: Simplify the needed includes for using Thread::current()
stefank
parents:
6985
diff
changeset
|
47 #include "runtime/thread.inline.hpp" |
| 1972 | 48 #include "services/attachListener.hpp" |
| 6197 | 49 #include "services/memTracker.hpp" |
| 1972 | 50 #include "services/threadService.hpp" |
| 51 #include "utilities/defaultStream.hpp" | |
| 52 #include "utilities/events.hpp" | |
| 53 #ifdef TARGET_OS_FAMILY_linux | |
| 54 # include "os_linux.inline.hpp" | |
| 55 #endif | |
| 56 #ifdef TARGET_OS_FAMILY_solaris | |
| 57 # include "os_solaris.inline.hpp" | |
| 58 #endif | |
| 59 #ifdef TARGET_OS_FAMILY_windows | |
| 60 # include "os_windows.inline.hpp" | |
| 61 #endif | |
| 3960 | 62 #ifdef TARGET_OS_FAMILY_bsd |
| 63 # include "os_bsd.inline.hpp" | |
| 64 #endif | |
| 0 | 65 |
| 66 # include <signal.h> | |
| 67 | |
| 68 OSThread* os::_starting_thread = NULL; | |
| 69 address os::_polling_page = NULL; | |
| 70 volatile int32_t* os::_mem_serialize_page = NULL; | |
| 71 uintptr_t os::_serialize_page_mask = 0; | |
| 72 long os::_rand_seed = 1; | |
| 73 int os::_processor_count = 0; | |
| 74 size_t os::_page_sizes[os::page_sizes_max]; | |
| 75 | |
| 76 #ifndef PRODUCT | |
| 2250 | 77 julong os::num_mallocs = 0; // # of calls to malloc/realloc |
| 78 julong os::alloc_bytes = 0; // # of bytes allocated | |
| 79 julong os::num_frees = 0; // # of calls to free | |
| 80 julong os::free_bytes = 0; // # of bytes freed | |
| 0 | 81 #endif |
| 82 | |
|
8802
eca90b8a06eb
7030610: runtime/6878713/Test6878713.sh fails Error. failed to clean up files after test
rdurbin
parents:
7994
diff
changeset
|
83 static juint cur_malloc_words = 0; // current size for MallocMaxTestWords |
|
eca90b8a06eb
7030610: runtime/6878713/Test6878713.sh fails Error. failed to clean up files after test
rdurbin
parents:
7994
diff
changeset
|
84 |
|
4749
7ab5f6318694
7125934: Add a fast unordered timestamp capability to Hotspot on x86/x64
phh
parents:
4006
diff
changeset
|
85 void os_init_globals() { |
|
7ab5f6318694
7125934: Add a fast unordered timestamp capability to Hotspot on x86/x64
phh
parents:
4006
diff
changeset
|
86 // Called from init_globals(). |
|
7ab5f6318694
7125934: Add a fast unordered timestamp capability to Hotspot on x86/x64
phh
parents:
4006
diff
changeset
|
87 // See Threads::create_vm() in thread.cpp, and init.cpp. |
|
7ab5f6318694
7125934: Add a fast unordered timestamp capability to Hotspot on x86/x64
phh
parents:
4006
diff
changeset
|
88 os::init_globals(); |
|
7ab5f6318694
7125934: Add a fast unordered timestamp capability to Hotspot on x86/x64
phh
parents:
4006
diff
changeset
|
89 } |
|
7ab5f6318694
7125934: Add a fast unordered timestamp capability to Hotspot on x86/x64
phh
parents:
4006
diff
changeset
|
90 |
| 0 | 91 // Fill in buffer with current local time as an ISO-8601 string. |
| 92 // E.g., yyyy-mm-ddThh:mm:ss-zzzz. | |
| 93 // Returns buffer, or NULL if it failed. | |
| 94 // This would mostly be a call to | |
| 95 // strftime(...., "%Y-%m-%d" "T" "%H:%M:%S" "%z", ....) | |
| 96 // except that on Windows the %z behaves badly, so we do it ourselves. | |
| 97 // Also, people wanted milliseconds on there, | |
| 98 // and strftime doesn't do milliseconds. | |
| 99 char* os::iso8601_time(char* buffer, size_t buffer_length) { | |
| 100 // Output will be of the form "YYYY-MM-DDThh:mm:ss.mmm+zzzz\0" | |
| 101 // 1 2 | |
| 102 // 12345678901234567890123456789 | |
| 103 static const char* iso8601_format = | |
| 104 "%04d-%02d-%02dT%02d:%02d:%02d.%03d%c%02d%02d"; | |
| 105 static const size_t needed_buffer = 29; | |
| 106 | |
| 107 // Sanity check the arguments | |
| 108 if (buffer == NULL) { | |
| 109 assert(false, "NULL buffer"); | |
| 110 return NULL; | |
| 111 } | |
| 112 if (buffer_length < needed_buffer) { | |
| 113 assert(false, "buffer_length too small"); | |
| 114 return NULL; | |
| 115 } | |
| 116 // Get the current time | |
| 61 | 117 jlong milliseconds_since_19700101 = javaTimeMillis(); |
| 0 | 118 const int milliseconds_per_microsecond = 1000; |
| 119 const time_t seconds_since_19700101 = | |
| 120 milliseconds_since_19700101 / milliseconds_per_microsecond; | |
| 121 const int milliseconds_after_second = | |
| 122 milliseconds_since_19700101 % milliseconds_per_microsecond; | |
| 123 // Convert the time value to a tm and timezone variable | |
|
548
773234c55e8c
6800586: -XX:+PrintGCDateStamps is using mt-unsafe localtime function
ysr
parents:
477
diff
changeset
|
124 struct tm time_struct; |
|
773234c55e8c
6800586: -XX:+PrintGCDateStamps is using mt-unsafe localtime function
ysr
parents:
477
diff
changeset
|
125 if (localtime_pd(&seconds_since_19700101, &time_struct) == NULL) { |
|
773234c55e8c
6800586: -XX:+PrintGCDateStamps is using mt-unsafe localtime function
ysr
parents:
477
diff
changeset
|
126 assert(false, "Failed localtime_pd"); |
| 0 | 127 return NULL; |
| 128 } | |
| 3960 | 129 #if defined(_ALLBSD_SOURCE) |
| 130 const time_t zone = (time_t) time_struct.tm_gmtoff; | |
| 131 #else | |
| 0 | 132 const time_t zone = timezone; |
| 3960 | 133 #endif |
| 0 | 134 |
| 135 // If daylight savings time is in effect, | |
| 136 // we are 1 hour East of our time zone | |
| 137 const time_t seconds_per_minute = 60; | |
| 138 const time_t minutes_per_hour = 60; | |
| 139 const time_t seconds_per_hour = seconds_per_minute * minutes_per_hour; | |
| 140 time_t UTC_to_local = zone; | |
| 141 if (time_struct.tm_isdst > 0) { | |
| 142 UTC_to_local = UTC_to_local - seconds_per_hour; | |
| 143 } | |
| 144 // Compute the time zone offset. | |
|
548
773234c55e8c
6800586: -XX:+PrintGCDateStamps is using mt-unsafe localtime function
ysr
parents:
477
diff
changeset
|
145 // localtime_pd() sets timezone to the difference (in seconds) |
| 0 | 146 // between UTC and and local time. |
| 147 // ISO 8601 says we need the difference between local time and UTC, | |
|
548
773234c55e8c
6800586: -XX:+PrintGCDateStamps is using mt-unsafe localtime function
ysr
parents:
477
diff
changeset
|
148 // we change the sign of the localtime_pd() result. |
| 0 | 149 const time_t local_to_UTC = -(UTC_to_local); |
| 150 // Then we have to figure out if if we are ahead (+) or behind (-) UTC. | |
| 151 char sign_local_to_UTC = '+'; | |
| 152 time_t abs_local_to_UTC = local_to_UTC; | |
| 153 if (local_to_UTC < 0) { | |
| 154 sign_local_to_UTC = '-'; | |
| 155 abs_local_to_UTC = -(abs_local_to_UTC); | |
| 156 } | |
| 157 // Convert time zone offset seconds to hours and minutes. | |
| 158 const time_t zone_hours = (abs_local_to_UTC / seconds_per_hour); | |
| 159 const time_t zone_min = | |
| 160 ((abs_local_to_UTC % seconds_per_hour) / seconds_per_minute); | |
| 161 | |
| 162 // Print an ISO 8601 date and time stamp into the buffer | |
| 163 const int year = 1900 + time_struct.tm_year; | |
| 164 const int month = 1 + time_struct.tm_mon; | |
| 165 const int printed = jio_snprintf(buffer, buffer_length, iso8601_format, | |
| 166 year, | |
| 167 month, | |
| 168 time_struct.tm_mday, | |
| 169 time_struct.tm_hour, | |
| 170 time_struct.tm_min, | |
| 171 time_struct.tm_sec, | |
| 172 milliseconds_after_second, | |
| 173 sign_local_to_UTC, | |
| 174 zone_hours, | |
| 175 zone_min); | |
| 176 if (printed == 0) { | |
| 177 assert(false, "Failed jio_printf"); | |
| 178 return NULL; | |
| 179 } | |
| 180 return buffer; | |
| 181 } | |
| 182 | |
| 183 OSReturn os::set_priority(Thread* thread, ThreadPriority p) { | |
| 184 #ifdef ASSERT | |
| 185 if (!(!thread->is_Java_thread() || | |
| 186 Thread::current() == thread || | |
| 187 Threads_lock->owned_by_self() | |
| 188 || thread->is_Compiler_thread() | |
| 189 )) { | |
| 190 assert(false, "possibility of dangling Thread pointer"); | |
| 191 } | |
| 192 #endif | |
| 193 | |
| 194 if (p >= MinPriority && p <= MaxPriority) { | |
| 195 int priority = java_to_os_priority[p]; | |
| 196 return set_native_priority(thread, priority); | |
| 197 } else { | |
| 198 assert(false, "Should not happen"); | |
| 199 return OS_ERR; | |
| 200 } | |
| 201 } | |
| 202 | |
| 6766 | 203 // The mapping from OS priority back to Java priority may be inexact because |
| 204 // Java priorities can map M:1 with native priorities. If you want the definite | |
| 205 // Java priority then use JavaThread::java_priority() | |
| 0 | 206 OSReturn os::get_priority(const Thread* const thread, ThreadPriority& priority) { |
| 207 int p; | |
| 208 int os_prio; | |
| 209 OSReturn ret = get_native_priority(thread, &os_prio); | |
| 210 if (ret != OS_OK) return ret; | |
| 211 | |
| 6766 | 212 if (java_to_os_priority[MaxPriority] > java_to_os_priority[MinPriority]) { |
| 213 for (p = MaxPriority; p > MinPriority && java_to_os_priority[p] > os_prio; p--) ; | |
| 214 } else { | |
| 215 // niceness values are in reverse order | |
| 216 for (p = MaxPriority; p > MinPriority && java_to_os_priority[p] < os_prio; p--) ; | |
| 217 } | |
| 0 | 218 priority = (ThreadPriority)p; |
| 219 return OS_OK; | |
| 220 } | |
| 221 | |
| 222 | |
| 223 // --------------------- sun.misc.Signal (optional) --------------------- | |
| 224 | |
| 225 | |
| 226 // SIGBREAK is sent by the keyboard to query the VM state | |
| 227 #ifndef SIGBREAK | |
| 228 #define SIGBREAK SIGQUIT | |
| 229 #endif | |
| 230 | |
| 231 // sigexitnum_pd is a platform-specific special signal used for terminating the Signal thread. | |
| 232 | |
| 233 | |
| 234 static void signal_thread_entry(JavaThread* thread, TRAPS) { | |
| 235 os::set_priority(thread, NearMaxPriority); | |
| 236 while (true) { | |
| 237 int sig; | |
| 238 { | |
| 239 // FIXME : Currently we have not decieded what should be the status | |
| 240 // for this java thread blocked here. Once we decide about | |
| 241 // that we should fix this. | |
| 242 sig = os::signal_wait(); | |
| 243 } | |
| 244 if (sig == os::sigexitnum_pd()) { | |
| 245 // Terminate the signal thread | |
| 246 return; | |
| 247 } | |
| 248 | |
| 249 switch (sig) { | |
| 250 case SIGBREAK: { | |
| 251 // Check if the signal is a trigger to start the Attach Listener - in that | |
| 252 // case don't print stack traces. | |
| 253 if (!DisableAttachMechanism && AttachListener::is_init_trigger()) { | |
| 254 continue; | |
| 255 } | |
| 256 // Print stack traces | |
| 257 // Any SIGBREAK operations added here should make sure to flush | |
| 258 // the output stream (e.g. tty->flush()) after output. See 4803766. | |
| 259 // Each module also prints an extra carriage return after its output. | |
| 260 VM_PrintThreads op; | |
| 261 VMThread::execute(&op); | |
| 262 VM_PrintJNI jni_op; | |
| 263 VMThread::execute(&jni_op); | |
| 264 VM_FindDeadlocks op1(tty); | |
| 265 VMThread::execute(&op1); | |
| 266 Universe::print_heap_at_SIGBREAK(); | |
| 267 if (PrintClassHistogram) { | |
|
615
c6c601a0f2d6
6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents:
548
diff
changeset
|
268 VM_GC_HeapInspection op1(gclog_or_tty, true /* force full GC before heap inspection */, |
|
c6c601a0f2d6
6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents:
548
diff
changeset
|
269 true /* need_prologue */); |
| 0 | 270 VMThread::execute(&op1); |
| 271 } | |
| 272 if (JvmtiExport::should_post_data_dump()) { | |
| 273 JvmtiExport::post_data_dump(); | |
| 274 } | |
| 275 break; | |
| 276 } | |
| 277 default: { | |
| 278 // Dispatch the signal to java | |
| 279 HandleMark hm(THREAD); | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
280 Klass* k = SystemDictionary::resolve_or_null(vmSymbols::sun_misc_Signal(), THREAD); |
| 0 | 281 KlassHandle klass (THREAD, k); |
| 282 if (klass.not_null()) { | |
| 283 JavaValue result(T_VOID); | |
| 284 JavaCallArguments args; | |
| 285 args.push_int(sig); | |
| 286 JavaCalls::call_static( | |
| 287 &result, | |
| 288 klass, | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1980
diff
changeset
|
289 vmSymbols::dispatch_name(), |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1980
diff
changeset
|
290 vmSymbols::int_void_signature(), |
| 0 | 291 &args, |
| 292 THREAD | |
| 293 ); | |
| 294 } | |
| 295 if (HAS_PENDING_EXCEPTION) { | |
| 296 // tty is initialized early so we don't expect it to be null, but | |
| 297 // if it is we can't risk doing an initialization that might | |
| 298 // trigger additional out-of-memory conditions | |
| 299 if (tty != NULL) { | |
| 300 char klass_name[256]; | |
| 301 char tmp_sig_name[16]; | |
| 302 const char* sig_name = "UNKNOWN"; | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
303 InstanceKlass::cast(PENDING_EXCEPTION->klass())-> |
| 0 | 304 name()->as_klass_external_name(klass_name, 256); |
| 305 if (os::exception_name(sig, tmp_sig_name, 16) != NULL) | |
| 306 sig_name = tmp_sig_name; | |
| 307 warning("Exception %s occurred dispatching signal %s to handler" | |
| 308 "- the VM may need to be forcibly terminated", | |
| 309 klass_name, sig_name ); | |
| 310 } | |
| 311 CLEAR_PENDING_EXCEPTION; | |
| 312 } | |
| 313 } | |
| 314 } | |
| 315 } | |
| 316 } | |
| 317 | |
| 318 | |
| 319 void os::signal_init() { | |
| 320 if (!ReduceSignalUsage) { | |
| 321 // Setup JavaThread for processing signals | |
| 322 EXCEPTION_MARK; | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
323 Klass* k = SystemDictionary::resolve_or_fail(vmSymbols::java_lang_Thread(), true, CHECK); |
| 0 | 324 instanceKlassHandle klass (THREAD, k); |
| 325 instanceHandle thread_oop = klass->allocate_instance_handle(CHECK); | |
| 326 | |
| 327 const char thread_name[] = "Signal Dispatcher"; | |
| 328 Handle string = java_lang_String::create_from_str(thread_name, CHECK); | |
| 329 | |
| 330 // Initialize thread_oop to put it into the system threadGroup | |
| 331 Handle thread_group (THREAD, Universe::system_thread_group()); | |
| 332 JavaValue result(T_VOID); | |
| 333 JavaCalls::call_special(&result, thread_oop, | |
| 334 klass, | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1980
diff
changeset
|
335 vmSymbols::object_initializer_name(), |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1980
diff
changeset
|
336 vmSymbols::threadgroup_string_void_signature(), |
| 0 | 337 thread_group, |
| 338 string, | |
| 339 CHECK); | |
| 340 | |
| 1142 | 341 KlassHandle group(THREAD, SystemDictionary::ThreadGroup_klass()); |
| 0 | 342 JavaCalls::call_special(&result, |
| 343 thread_group, | |
| 344 group, | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1980
diff
changeset
|
345 vmSymbols::add_method_name(), |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1980
diff
changeset
|
346 vmSymbols::thread_void_signature(), |
| 0 | 347 thread_oop, // ARG 1 |
| 348 CHECK); | |
| 349 | |
| 350 os::signal_init_pd(); | |
| 351 | |
| 352 { MutexLocker mu(Threads_lock); | |
| 353 JavaThread* signal_thread = new JavaThread(&signal_thread_entry); | |
| 354 | |
| 355 // At this point it may be possible that no osthread was created for the | |
| 356 // JavaThread due to lack of memory. We would have to throw an exception | |
| 357 // in that case. However, since this must work and we do not allow | |
| 358 // exceptions anyway, check and abort if this fails. | |
| 359 if (signal_thread == NULL || signal_thread->osthread() == NULL) { | |
| 360 vm_exit_during_initialization("java.lang.OutOfMemoryError", | |
| 361 "unable to create new native thread"); | |
| 362 } | |
| 363 | |
| 364 java_lang_Thread::set_thread(thread_oop(), signal_thread); | |
| 365 java_lang_Thread::set_priority(thread_oop(), NearMaxPriority); | |
| 366 java_lang_Thread::set_daemon(thread_oop()); | |
| 367 | |
| 368 signal_thread->set_threadObj(thread_oop()); | |
| 369 Threads::add(signal_thread); | |
| 370 Thread::start(signal_thread); | |
| 371 } | |
| 372 // Handle ^BREAK | |
| 373 os::signal(SIGBREAK, os::user_handler()); | |
| 374 } | |
| 375 } | |
| 376 | |
| 377 | |
| 378 void os::terminate_signal_thread() { | |
| 379 if (!ReduceSignalUsage) | |
| 380 signal_notify(sigexitnum_pd()); | |
| 381 } | |
| 382 | |
| 383 | |
| 384 // --------------------- loading libraries --------------------- | |
| 385 | |
| 386 typedef jint (JNICALL *JNI_OnLoad_t)(JavaVM *, void *); | |
| 387 extern struct JavaVM_ main_vm; | |
| 388 | |
| 389 static void* _native_java_library = NULL; | |
| 390 | |
| 391 void* os::native_java_library() { | |
| 392 if (_native_java_library == NULL) { | |
| 393 char buffer[JVM_MAXPATHLEN]; | |
| 394 char ebuf[1024]; | |
| 395 | |
| 242 | 396 // Try to load verify dll first. In 1.3 java dll depends on it and is not |
| 397 // always able to find it when the loading executable is outside the JDK. | |
| 0 | 398 // In order to keep working with 1.2 we ignore any loading errors. |
|
6966
6cb0d32b828b
8001185: parsing of sun.boot.library.path in os::dll_build_name somewhat broken
bpittore
parents:
6882
diff
changeset
|
399 if (dll_build_name(buffer, sizeof(buffer), Arguments::get_dll_dir(), |
|
6cb0d32b828b
8001185: parsing of sun.boot.library.path in os::dll_build_name somewhat broken
bpittore
parents:
6882
diff
changeset
|
400 "verify")) { |
|
6cb0d32b828b
8001185: parsing of sun.boot.library.path in os::dll_build_name somewhat broken
bpittore
parents:
6882
diff
changeset
|
401 dll_load(buffer, ebuf, sizeof(ebuf)); |
|
6cb0d32b828b
8001185: parsing of sun.boot.library.path in os::dll_build_name somewhat broken
bpittore
parents:
6882
diff
changeset
|
402 } |
| 0 | 403 |
| 404 // Load java dll | |
|
6966
6cb0d32b828b
8001185: parsing of sun.boot.library.path in os::dll_build_name somewhat broken
bpittore
parents:
6882
diff
changeset
|
405 if (dll_build_name(buffer, sizeof(buffer), Arguments::get_dll_dir(), |
|
6cb0d32b828b
8001185: parsing of sun.boot.library.path in os::dll_build_name somewhat broken
bpittore
parents:
6882
diff
changeset
|
406 "java")) { |
|
6cb0d32b828b
8001185: parsing of sun.boot.library.path in os::dll_build_name somewhat broken
bpittore
parents:
6882
diff
changeset
|
407 _native_java_library = dll_load(buffer, ebuf, sizeof(ebuf)); |
|
6cb0d32b828b
8001185: parsing of sun.boot.library.path in os::dll_build_name somewhat broken
bpittore
parents:
6882
diff
changeset
|
408 } |
| 0 | 409 if (_native_java_library == NULL) { |
| 410 vm_exit_during_initialization("Unable to load native library", ebuf); | |
| 411 } | |
| 3960 | 412 |
| 413 #if defined(__OpenBSD__) | |
| 414 // Work-around OpenBSD's lack of $ORIGIN support by pre-loading libnet.so | |
| 415 // ignore errors | |
|
6966
6cb0d32b828b
8001185: parsing of sun.boot.library.path in os::dll_build_name somewhat broken
bpittore
parents:
6882
diff
changeset
|
416 if (dll_build_name(buffer, sizeof(buffer), Arguments::get_dll_dir(), |
|
6cb0d32b828b
8001185: parsing of sun.boot.library.path in os::dll_build_name somewhat broken
bpittore
parents:
6882
diff
changeset
|
417 "net")) { |
|
6cb0d32b828b
8001185: parsing of sun.boot.library.path in os::dll_build_name somewhat broken
bpittore
parents:
6882
diff
changeset
|
418 dll_load(buffer, ebuf, sizeof(ebuf)); |
|
6cb0d32b828b
8001185: parsing of sun.boot.library.path in os::dll_build_name somewhat broken
bpittore
parents:
6882
diff
changeset
|
419 } |
| 3960 | 420 #endif |
| 242 | 421 } |
| 422 static jboolean onLoaded = JNI_FALSE; | |
| 423 if (onLoaded) { | |
| 424 // We may have to wait to fire OnLoad until TLS is initialized. | |
| 425 if (ThreadLocalStorage::is_initialized()) { | |
| 426 // The JNI_OnLoad handling is normally done by method load in | |
| 427 // java.lang.ClassLoader$NativeLibrary, but the VM loads the base library | |
| 428 // explicitly so we have to check for JNI_OnLoad as well | |
| 429 const char *onLoadSymbols[] = JNI_ONLOAD_SYMBOLS; | |
| 430 JNI_OnLoad_t JNI_OnLoad = CAST_TO_FN_PTR( | |
| 431 JNI_OnLoad_t, dll_lookup(_native_java_library, onLoadSymbols[0])); | |
| 432 if (JNI_OnLoad != NULL) { | |
| 433 JavaThread* thread = JavaThread::current(); | |
| 434 ThreadToNativeFromVM ttn(thread); | |
| 435 HandleMark hm(thread); | |
| 436 jint ver = (*JNI_OnLoad)(&main_vm, NULL); | |
| 437 onLoaded = JNI_TRUE; | |
| 438 if (!Threads::is_supported_jni_version_including_1_1(ver)) { | |
| 439 vm_exit_during_initialization("Unsupported JNI version"); | |
| 440 } | |
| 0 | 441 } |
| 442 } | |
| 443 } | |
| 444 return _native_java_library; | |
| 445 } | |
| 446 | |
| 447 // --------------------- heap allocation utilities --------------------- | |
| 448 | |
| 6197 | 449 char *os::strdup(const char *str, MEMFLAGS flags) { |
| 0 | 450 size_t size = strlen(str); |
| 6197 | 451 char *dup_str = (char *)malloc(size + 1, flags); |
| 0 | 452 if (dup_str == NULL) return NULL; |
| 453 strcpy(dup_str, str); | |
| 454 return dup_str; | |
| 455 } | |
| 456 | |
| 457 | |
| 458 | |
| 459 #ifdef ASSERT | |
| 460 #define space_before (MallocCushion + sizeof(double)) | |
| 461 #define space_after MallocCushion | |
| 462 #define size_addr_from_base(p) (size_t*)(p + space_before - sizeof(size_t)) | |
| 463 #define size_addr_from_obj(p) ((size_t*)p - 1) | |
| 464 // MallocCushion: size of extra cushion allocated around objects with +UseMallocOnly | |
| 465 // NB: cannot be debug variable, because these aren't set from the command line until | |
| 466 // *after* the first few allocs already happened | |
| 467 #define MallocCushion 16 | |
| 468 #else | |
| 469 #define space_before 0 | |
| 470 #define space_after 0 | |
| 471 #define size_addr_from_base(p) should not use w/o ASSERT | |
| 472 #define size_addr_from_obj(p) should not use w/o ASSERT | |
| 473 #define MallocCushion 0 | |
| 474 #endif | |
| 475 #define paranoid 0 /* only set to 1 if you suspect checking code has bug */ | |
| 476 | |
| 477 #ifdef ASSERT | |
| 478 inline size_t get_size(void* obj) { | |
| 479 size_t size = *size_addr_from_obj(obj); | |
|
1490
f03d0a26bf83
6888954: argument formatting for assert() and friends
jcoomes
parents:
1142
diff
changeset
|
480 if (size < 0) { |
|
f03d0a26bf83
6888954: argument formatting for assert() and friends
jcoomes
parents:
1142
diff
changeset
|
481 fatal(err_msg("free: size field of object #" PTR_FORMAT " was overwritten (" |
|
f03d0a26bf83
6888954: argument formatting for assert() and friends
jcoomes
parents:
1142
diff
changeset
|
482 SIZE_FORMAT ")", obj, size)); |
|
f03d0a26bf83
6888954: argument formatting for assert() and friends
jcoomes
parents:
1142
diff
changeset
|
483 } |
| 0 | 484 return size; |
| 485 } | |
| 486 | |
| 487 u_char* find_cushion_backwards(u_char* start) { | |
| 488 u_char* p = start; | |
| 489 while (p[ 0] != badResourceValue || p[-1] != badResourceValue || | |
| 490 p[-2] != badResourceValue || p[-3] != badResourceValue) p--; | |
| 491 // ok, we have four consecutive marker bytes; find start | |
| 492 u_char* q = p - 4; | |
| 493 while (*q == badResourceValue) q--; | |
| 494 return q + 1; | |
| 495 } | |
| 496 | |
| 497 u_char* find_cushion_forwards(u_char* start) { | |
| 498 u_char* p = start; | |
| 499 while (p[0] != badResourceValue || p[1] != badResourceValue || | |
| 500 p[2] != badResourceValue || p[3] != badResourceValue) p++; | |
| 501 // ok, we have four consecutive marker bytes; find end of cushion | |
| 502 u_char* q = p + 4; | |
| 503 while (*q == badResourceValue) q++; | |
| 504 return q - MallocCushion; | |
| 505 } | |
| 506 | |
| 507 void print_neighbor_blocks(void* ptr) { | |
| 508 // find block allocated before ptr (not entirely crash-proof) | |
| 509 if (MallocCushion < 4) { | |
| 510 tty->print_cr("### cannot find previous block (MallocCushion < 4)"); | |
| 511 return; | |
| 512 } | |
| 513 u_char* start_of_this_block = (u_char*)ptr - space_before; | |
| 514 u_char* end_of_prev_block_data = start_of_this_block - space_after -1; | |
| 515 // look for cushion in front of prev. block | |
| 516 u_char* start_of_prev_block = find_cushion_backwards(end_of_prev_block_data); | |
| 517 ptrdiff_t size = *size_addr_from_base(start_of_prev_block); | |
| 518 u_char* obj = start_of_prev_block + space_before; | |
| 519 if (size <= 0 ) { | |
| 520 // start is bad; mayhave been confused by OS data inbetween objects | |
| 521 // search one more backwards | |
| 522 start_of_prev_block = find_cushion_backwards(start_of_prev_block); | |
| 523 size = *size_addr_from_base(start_of_prev_block); | |
| 524 obj = start_of_prev_block + space_before; | |
| 525 } | |
| 526 | |
| 527 if (start_of_prev_block + space_before + size + space_after == start_of_this_block) { | |
| 2250 | 528 tty->print_cr("### previous object: " PTR_FORMAT " (" SSIZE_FORMAT " bytes)", obj, size); |
| 0 | 529 } else { |
| 2250 | 530 tty->print_cr("### previous object (not sure if correct): " PTR_FORMAT " (" SSIZE_FORMAT " bytes)", obj, size); |
| 0 | 531 } |
| 532 | |
| 533 // now find successor block | |
| 534 u_char* start_of_next_block = (u_char*)ptr + *size_addr_from_obj(ptr) + space_after; | |
| 535 start_of_next_block = find_cushion_forwards(start_of_next_block); | |
| 536 u_char* next_obj = start_of_next_block + space_before; | |
| 537 ptrdiff_t next_size = *size_addr_from_base(start_of_next_block); | |
| 538 if (start_of_next_block[0] == badResourceValue && | |
| 539 start_of_next_block[1] == badResourceValue && | |
| 540 start_of_next_block[2] == badResourceValue && | |
| 541 start_of_next_block[3] == badResourceValue) { | |
| 2250 | 542 tty->print_cr("### next object: " PTR_FORMAT " (" SSIZE_FORMAT " bytes)", next_obj, next_size); |
| 0 | 543 } else { |
| 2250 | 544 tty->print_cr("### next object (not sure if correct): " PTR_FORMAT " (" SSIZE_FORMAT " bytes)", next_obj, next_size); |
| 0 | 545 } |
| 546 } | |
| 547 | |
| 548 | |
| 549 void report_heap_error(void* memblock, void* bad, const char* where) { | |
| 2250 | 550 tty->print_cr("## nof_mallocs = " UINT64_FORMAT ", nof_frees = " UINT64_FORMAT, os::num_mallocs, os::num_frees); |
| 551 tty->print_cr("## memory stomp: byte at " PTR_FORMAT " %s object " PTR_FORMAT, bad, where, memblock); | |
| 0 | 552 print_neighbor_blocks(memblock); |
| 553 fatal("memory stomping error"); | |
| 554 } | |
| 555 | |
| 556 void verify_block(void* memblock) { | |
| 557 size_t size = get_size(memblock); | |
| 558 if (MallocCushion) { | |
| 559 u_char* ptr = (u_char*)memblock - space_before; | |
| 560 for (int i = 0; i < MallocCushion; i++) { | |
| 561 if (ptr[i] != badResourceValue) { | |
| 562 report_heap_error(memblock, ptr+i, "in front of"); | |
| 563 } | |
| 564 } | |
| 565 u_char* end = (u_char*)memblock + size + space_after; | |
| 566 for (int j = -MallocCushion; j < 0; j++) { | |
| 567 if (end[j] != badResourceValue) { | |
| 568 report_heap_error(memblock, end+j, "after"); | |
| 569 } | |
| 570 } | |
| 571 } | |
| 572 } | |
| 573 #endif | |
| 574 | |
|
8802
eca90b8a06eb
7030610: runtime/6878713/Test6878713.sh fails Error. failed to clean up files after test
rdurbin
parents:
7994
diff
changeset
|
575 // |
|
eca90b8a06eb
7030610: runtime/6878713/Test6878713.sh fails Error. failed to clean up files after test
rdurbin
parents:
7994
diff
changeset
|
576 // This function supports testing of the malloc out of memory |
|
eca90b8a06eb
7030610: runtime/6878713/Test6878713.sh fails Error. failed to clean up files after test
rdurbin
parents:
7994
diff
changeset
|
577 // condition without really running the system out of memory. |
|
eca90b8a06eb
7030610: runtime/6878713/Test6878713.sh fails Error. failed to clean up files after test
rdurbin
parents:
7994
diff
changeset
|
578 // |
|
eca90b8a06eb
7030610: runtime/6878713/Test6878713.sh fails Error. failed to clean up files after test
rdurbin
parents:
7994
diff
changeset
|
579 static u_char* testMalloc(size_t alloc_size) { |
|
8808
81d1b58c078f
8010396: checking MallocMaxTestWords in testMalloc() function is redundant
rdurbin
parents:
8802
diff
changeset
|
580 assert(MallocMaxTestWords > 0, "sanity check"); |
|
8802
eca90b8a06eb
7030610: runtime/6878713/Test6878713.sh fails Error. failed to clean up files after test
rdurbin
parents:
7994
diff
changeset
|
581 |
|
8808
81d1b58c078f
8010396: checking MallocMaxTestWords in testMalloc() function is redundant
rdurbin
parents:
8802
diff
changeset
|
582 if ((cur_malloc_words + (alloc_size / BytesPerWord)) > MallocMaxTestWords) { |
|
8802
eca90b8a06eb
7030610: runtime/6878713/Test6878713.sh fails Error. failed to clean up files after test
rdurbin
parents:
7994
diff
changeset
|
583 return NULL; |
|
eca90b8a06eb
7030610: runtime/6878713/Test6878713.sh fails Error. failed to clean up files after test
rdurbin
parents:
7994
diff
changeset
|
584 } |
|
eca90b8a06eb
7030610: runtime/6878713/Test6878713.sh fails Error. failed to clean up files after test
rdurbin
parents:
7994
diff
changeset
|
585 |
|
eca90b8a06eb
7030610: runtime/6878713/Test6878713.sh fails Error. failed to clean up files after test
rdurbin
parents:
7994
diff
changeset
|
586 u_char* ptr = (u_char*)::malloc(alloc_size); |
|
eca90b8a06eb
7030610: runtime/6878713/Test6878713.sh fails Error. failed to clean up files after test
rdurbin
parents:
7994
diff
changeset
|
587 |
|
8808
81d1b58c078f
8010396: checking MallocMaxTestWords in testMalloc() function is redundant
rdurbin
parents:
8802
diff
changeset
|
588 if (ptr != NULL) { |
|
8802
eca90b8a06eb
7030610: runtime/6878713/Test6878713.sh fails Error. failed to clean up files after test
rdurbin
parents:
7994
diff
changeset
|
589 Atomic::add(((jint) (alloc_size / BytesPerWord)), |
|
eca90b8a06eb
7030610: runtime/6878713/Test6878713.sh fails Error. failed to clean up files after test
rdurbin
parents:
7994
diff
changeset
|
590 (volatile jint *) &cur_malloc_words); |
|
eca90b8a06eb
7030610: runtime/6878713/Test6878713.sh fails Error. failed to clean up files after test
rdurbin
parents:
7994
diff
changeset
|
591 } |
|
eca90b8a06eb
7030610: runtime/6878713/Test6878713.sh fails Error. failed to clean up files after test
rdurbin
parents:
7994
diff
changeset
|
592 return ptr; |
|
eca90b8a06eb
7030610: runtime/6878713/Test6878713.sh fails Error. failed to clean up files after test
rdurbin
parents:
7994
diff
changeset
|
593 } |
|
eca90b8a06eb
7030610: runtime/6878713/Test6878713.sh fails Error. failed to clean up files after test
rdurbin
parents:
7994
diff
changeset
|
594 |
| 6197 | 595 void* os::malloc(size_t size, MEMFLAGS memflags, address caller) { |
| 2250 | 596 NOT_PRODUCT(inc_stat_counter(&num_mallocs, 1)); |
| 597 NOT_PRODUCT(inc_stat_counter(&alloc_bytes, size)); | |
| 0 | 598 |
| 599 if (size == 0) { | |
| 600 // return a valid pointer if size is zero | |
| 601 // if NULL is returned the calling functions assume out of memory. | |
| 602 size = 1; | |
| 603 } | |
|
8802
eca90b8a06eb
7030610: runtime/6878713/Test6878713.sh fails Error. failed to clean up files after test
rdurbin
parents:
7994
diff
changeset
|
604 |
|
eca90b8a06eb
7030610: runtime/6878713/Test6878713.sh fails Error. failed to clean up files after test
rdurbin
parents:
7994
diff
changeset
|
605 const size_t alloc_size = size + space_before + space_after; |
|
eca90b8a06eb
7030610: runtime/6878713/Test6878713.sh fails Error. failed to clean up files after test
rdurbin
parents:
7994
diff
changeset
|
606 |
|
eca90b8a06eb
7030610: runtime/6878713/Test6878713.sh fails Error. failed to clean up files after test
rdurbin
parents:
7994
diff
changeset
|
607 if (size > alloc_size) { // Check for rollover. |
|
6982
e4f764ddb06a
7122219: Passed StringTableSize value not verified
hseigel
parents:
6882
diff
changeset
|
608 return NULL; |
|
e4f764ddb06a
7122219: Passed StringTableSize value not verified
hseigel
parents:
6882
diff
changeset
|
609 } |
|
8802
eca90b8a06eb
7030610: runtime/6878713/Test6878713.sh fails Error. failed to clean up files after test
rdurbin
parents:
7994
diff
changeset
|
610 |
| 0 | 611 NOT_PRODUCT(if (MallocVerifyInterval > 0) check_heap()); |
|
8802
eca90b8a06eb
7030610: runtime/6878713/Test6878713.sh fails Error. failed to clean up files after test
rdurbin
parents:
7994
diff
changeset
|
612 |
|
eca90b8a06eb
7030610: runtime/6878713/Test6878713.sh fails Error. failed to clean up files after test
rdurbin
parents:
7994
diff
changeset
|
613 u_char* ptr; |
|
eca90b8a06eb
7030610: runtime/6878713/Test6878713.sh fails Error. failed to clean up files after test
rdurbin
parents:
7994
diff
changeset
|
614 |
|
eca90b8a06eb
7030610: runtime/6878713/Test6878713.sh fails Error. failed to clean up files after test
rdurbin
parents:
7994
diff
changeset
|
615 if (MallocMaxTestWords > 0) { |
|
eca90b8a06eb
7030610: runtime/6878713/Test6878713.sh fails Error. failed to clean up files after test
rdurbin
parents:
7994
diff
changeset
|
616 ptr = testMalloc(alloc_size); |
|
eca90b8a06eb
7030610: runtime/6878713/Test6878713.sh fails Error. failed to clean up files after test
rdurbin
parents:
7994
diff
changeset
|
617 } else { |
|
eca90b8a06eb
7030610: runtime/6878713/Test6878713.sh fails Error. failed to clean up files after test
rdurbin
parents:
7994
diff
changeset
|
618 ptr = (u_char*)::malloc(alloc_size); |
|
eca90b8a06eb
7030610: runtime/6878713/Test6878713.sh fails Error. failed to clean up files after test
rdurbin
parents:
7994
diff
changeset
|
619 } |
| 6197 | 620 |
| 0 | 621 #ifdef ASSERT |
| 622 if (ptr == NULL) return NULL; | |
| 623 if (MallocCushion) { | |
| 624 for (u_char* p = ptr; p < ptr + MallocCushion; p++) *p = (u_char)badResourceValue; | |
| 625 u_char* end = ptr + space_before + size; | |
| 626 for (u_char* pq = ptr+MallocCushion; pq < end; pq++) *pq = (u_char)uninitBlockPad; | |
| 627 for (u_char* q = end; q < end + MallocCushion; q++) *q = (u_char)badResourceValue; | |
| 628 } | |
| 629 // put size just before data | |
| 630 *size_addr_from_base(ptr) = size; | |
| 631 #endif | |
| 632 u_char* memblock = ptr + space_before; | |
| 633 if ((intptr_t)memblock == (intptr_t)MallocCatchPtr) { | |
| 2250 | 634 tty->print_cr("os::malloc caught, " SIZE_FORMAT " bytes --> " PTR_FORMAT, size, memblock); |
| 0 | 635 breakpoint(); |
| 636 } | |
| 637 debug_only(if (paranoid) verify_block(memblock)); | |
| 2250 | 638 if (PrintMalloc && tty != NULL) tty->print_cr("os::malloc " SIZE_FORMAT " bytes --> " PTR_FORMAT, size, memblock); |
| 6197 | 639 |
| 640 // we do not track MallocCushion memory | |
| 641 MemTracker::record_malloc((address)memblock, size, memflags, caller == 0 ? CALLER_PC : caller); | |
| 642 | |
| 0 | 643 return memblock; |
| 644 } | |
| 645 | |
| 646 | |
| 6197 | 647 void* os::realloc(void *memblock, size_t size, MEMFLAGS memflags, address caller) { |
| 0 | 648 #ifndef ASSERT |
| 2250 | 649 NOT_PRODUCT(inc_stat_counter(&num_mallocs, 1)); |
| 650 NOT_PRODUCT(inc_stat_counter(&alloc_bytes, size)); | |
| 6197 | 651 void* ptr = ::realloc(memblock, size); |
|
6882
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6816
diff
changeset
|
652 if (ptr != NULL) { |
| 6197 | 653 MemTracker::record_realloc((address)memblock, (address)ptr, size, memflags, |
| 654 caller == 0 ? CALLER_PC : caller); | |
| 655 } | |
| 656 return ptr; | |
| 0 | 657 #else |
| 658 if (memblock == NULL) { | |
| 6197 | 659 return malloc(size, memflags, (caller == 0 ? CALLER_PC : caller)); |
| 0 | 660 } |
| 661 if ((intptr_t)memblock == (intptr_t)MallocCatchPtr) { | |
| 2250 | 662 tty->print_cr("os::realloc caught " PTR_FORMAT, memblock); |
| 0 | 663 breakpoint(); |
| 664 } | |
| 665 verify_block(memblock); | |
| 666 NOT_PRODUCT(if (MallocVerifyInterval > 0) check_heap()); | |
| 667 if (size == 0) return NULL; | |
| 668 // always move the block | |
| 6197 | 669 void* ptr = malloc(size, memflags, caller == 0 ? CALLER_PC : caller); |
| 2250 | 670 if (PrintMalloc) tty->print_cr("os::remalloc " SIZE_FORMAT " bytes, " PTR_FORMAT " --> " PTR_FORMAT, size, memblock, ptr); |
| 0 | 671 // Copy to new memory if malloc didn't fail |
| 672 if ( ptr != NULL ) { | |
| 673 memcpy(ptr, memblock, MIN2(size, get_size(memblock))); | |
| 674 if (paranoid) verify_block(ptr); | |
| 675 if ((intptr_t)ptr == (intptr_t)MallocCatchPtr) { | |
| 2250 | 676 tty->print_cr("os::realloc caught, " SIZE_FORMAT " bytes --> " PTR_FORMAT, size, ptr); |
| 0 | 677 breakpoint(); |
| 678 } | |
| 679 free(memblock); | |
| 680 } | |
| 681 return ptr; | |
| 682 #endif | |
| 683 } | |
| 684 | |
| 685 | |
| 6197 | 686 void os::free(void *memblock, MEMFLAGS memflags) { |
| 2250 | 687 NOT_PRODUCT(inc_stat_counter(&num_frees, 1)); |
| 0 | 688 #ifdef ASSERT |
| 689 if (memblock == NULL) return; | |
| 690 if ((intptr_t)memblock == (intptr_t)MallocCatchPtr) { | |
| 2250 | 691 if (tty != NULL) tty->print_cr("os::free caught " PTR_FORMAT, memblock); |
| 0 | 692 breakpoint(); |
| 693 } | |
| 694 verify_block(memblock); | |
| 695 NOT_PRODUCT(if (MallocVerifyInterval > 0) check_heap()); | |
| 696 // Added by detlefs. | |
| 697 if (MallocCushion) { | |
| 698 u_char* ptr = (u_char*)memblock - space_before; | |
| 699 for (u_char* p = ptr; p < ptr + MallocCushion; p++) { | |
| 700 guarantee(*p == badResourceValue, | |
| 701 "Thing freed should be malloc result."); | |
| 702 *p = (u_char)freeBlockPad; | |
| 703 } | |
| 704 size_t size = get_size(memblock); | |
| 2250 | 705 inc_stat_counter(&free_bytes, size); |
| 0 | 706 u_char* end = ptr + space_before + size; |
| 707 for (u_char* q = end; q < end + MallocCushion; q++) { | |
| 708 guarantee(*q == badResourceValue, | |
| 709 "Thing freed should be malloc result."); | |
| 710 *q = (u_char)freeBlockPad; | |
| 711 } | |
| 2250 | 712 if (PrintMalloc && tty != NULL) |
|
2333
f767174aac14
7021653: Parfait issue in hotspot/src/share/vm/oops/methodDataOops.hpp
coleenp
parents:
2250
diff
changeset
|
713 fprintf(stderr, "os::free " SIZE_FORMAT " bytes --> " PTR_FORMAT "\n", size, (uintptr_t)memblock); |
| 2250 | 714 } else if (PrintMalloc && tty != NULL) { |
| 715 // tty->print_cr("os::free %p", memblock); | |
|
2333
f767174aac14
7021653: Parfait issue in hotspot/src/share/vm/oops/methodDataOops.hpp
coleenp
parents:
2250
diff
changeset
|
716 fprintf(stderr, "os::free " PTR_FORMAT "\n", (uintptr_t)memblock); |
| 0 | 717 } |
| 718 #endif | |
| 6197 | 719 MemTracker::record_free((address)memblock, memflags); |
| 720 | |
| 0 | 721 ::free((char*)memblock - space_before); |
| 722 } | |
| 723 | |
| 724 void os::init_random(long initval) { | |
| 725 _rand_seed = initval; | |
| 726 } | |
| 727 | |
| 728 | |
| 729 long os::random() { | |
| 730 /* standard, well-known linear congruential random generator with | |
| 731 * next_rand = (16807*seed) mod (2**31-1) | |
| 732 * see | |
| 733 * (1) "Random Number Generators: Good Ones Are Hard to Find", | |
| 734 * S.K. Park and K.W. Miller, Communications of the ACM 31:10 (Oct 1988), | |
| 735 * (2) "Two Fast Implementations of the 'Minimal Standard' Random | |
| 736 * Number Generator", David G. Carta, Comm. ACM 33, 1 (Jan 1990), pp. 87-88. | |
| 737 */ | |
| 738 const long a = 16807; | |
| 739 const unsigned long m = 2147483647; | |
| 740 const long q = m / a; assert(q == 127773, "weird math"); | |
| 741 const long r = m % a; assert(r == 2836, "weird math"); | |
| 742 | |
| 743 // compute az=2^31p+q | |
| 744 unsigned long lo = a * (long)(_rand_seed & 0xFFFF); | |
| 745 unsigned long hi = a * (long)((unsigned long)_rand_seed >> 16); | |
| 746 lo += (hi & 0x7FFF) << 16; | |
| 747 | |
| 748 // if q overflowed, ignore the overflow and increment q | |
| 749 if (lo > m) { | |
| 750 lo &= m; | |
| 751 ++lo; | |
| 752 } | |
| 753 lo += hi >> 15; | |
| 754 | |
| 755 // if (p+q) overflowed, ignore the overflow and increment (p+q) | |
| 756 if (lo > m) { | |
| 757 lo &= m; | |
| 758 ++lo; | |
| 759 } | |
| 760 return (_rand_seed = lo); | |
| 761 } | |
| 762 | |
| 763 // The INITIALIZED state is distinguished from the SUSPENDED state because the | |
| 764 // conditions in which a thread is first started are different from those in which | |
| 765 // a suspension is resumed. These differences make it hard for us to apply the | |
| 766 // tougher checks when starting threads that we want to do when resuming them. | |
| 767 // However, when start_thread is called as a result of Thread.start, on a Java | |
| 768 // thread, the operation is synchronized on the Java Thread object. So there | |
| 769 // cannot be a race to start the thread and hence for the thread to exit while | |
| 770 // we are working on it. Non-Java threads that start Java threads either have | |
| 771 // to do so in a context in which races are impossible, or should do appropriate | |
| 772 // locking. | |
| 773 | |
| 774 void os::start_thread(Thread* thread) { | |
| 775 // guard suspend/resume | |
| 776 MutexLockerEx ml(thread->SR_lock(), Mutex::_no_safepoint_check_flag); | |
| 777 OSThread* osthread = thread->osthread(); | |
| 778 osthread->set_state(RUNNABLE); | |
| 779 pd_start_thread(thread); | |
| 780 } | |
| 781 | |
| 782 //--------------------------------------------------------------------------- | |
| 783 // Helper functions for fatal error handler | |
| 784 | |
| 785 void os::print_hex_dump(outputStream* st, address start, address end, int unitsize) { | |
| 786 assert(unitsize == 1 || unitsize == 2 || unitsize == 4 || unitsize == 8, "just checking"); | |
| 787 | |
| 788 int cols = 0; | |
| 789 int cols_per_line = 0; | |
| 790 switch (unitsize) { | |
| 791 case 1: cols_per_line = 16; break; | |
| 792 case 2: cols_per_line = 8; break; | |
| 793 case 4: cols_per_line = 4; break; | |
| 794 case 8: cols_per_line = 2; break; | |
| 795 default: return; | |
| 796 } | |
| 797 | |
| 798 address p = start; | |
| 799 st->print(PTR_FORMAT ": ", start); | |
| 800 while (p < end) { | |
| 801 switch (unitsize) { | |
| 802 case 1: st->print("%02x", *(u1*)p); break; | |
| 803 case 2: st->print("%04x", *(u2*)p); break; | |
| 804 case 4: st->print("%08x", *(u4*)p); break; | |
| 805 case 8: st->print("%016" FORMAT64_MODIFIER "x", *(u8*)p); break; | |
| 806 } | |
| 807 p += unitsize; | |
| 808 cols++; | |
| 809 if (cols >= cols_per_line && p < end) { | |
| 810 cols = 0; | |
| 811 st->cr(); | |
| 812 st->print(PTR_FORMAT ": ", p); | |
| 813 } else { | |
| 814 st->print(" "); | |
| 815 } | |
| 816 } | |
| 817 st->cr(); | |
| 818 } | |
| 819 | |
| 820 void os::print_environment_variables(outputStream* st, const char** env_list, | |
| 821 char* buffer, int len) { | |
| 822 if (env_list) { | |
| 823 st->print_cr("Environment Variables:"); | |
| 824 | |
| 825 for (int i = 0; env_list[i] != NULL; i++) { | |
| 826 if (getenv(env_list[i], buffer, len)) { | |
| 827 st->print(env_list[i]); | |
| 828 st->print("="); | |
| 829 st->print_cr(buffer); | |
| 830 } | |
| 831 } | |
| 832 } | |
| 833 } | |
| 834 | |
| 835 void os::print_cpu_info(outputStream* st) { | |
| 836 // cpu | |
| 837 st->print("CPU:"); | |
| 838 st->print("total %d", os::processor_count()); | |
| 839 // It's not safe to query number of active processors after crash | |
| 840 // st->print("(active %d)", os::active_processor_count()); | |
| 841 st->print(" %s", VM_Version::cpu_features()); | |
| 842 st->cr(); | |
|
3800
bf6481e5f96d
7061225: os::print_cpu_info() should support os-specific data
jcoomes
parents:
2469
diff
changeset
|
843 pd_print_cpu_info(st); |
| 0 | 844 } |
| 845 | |
| 846 void os::print_date_and_time(outputStream *st) { | |
| 847 time_t tloc; | |
| 848 (void)time(&tloc); | |
| 849 st->print("time: %s", ctime(&tloc)); // ctime adds newline. | |
| 850 | |
| 851 double t = os::elapsedTime(); | |
| 852 // NOTE: It tends to crash after a SEGV if we want to printf("%f",...) in | |
| 853 // Linux. Must be a bug in glibc ? Workaround is to round "t" to int | |
| 854 // before printf. We lost some precision, but who cares? | |
| 855 st->print_cr("elapsed time: %d seconds", (int)t); | |
| 856 } | |
| 857 | |
|
1681
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
858 // moved from debug.cpp (used to be find()) but still called from there |
| 1907 | 859 // The verbose parameter is only set by the debug code in one case |
| 860 void os::print_location(outputStream* st, intptr_t x, bool verbose) { | |
|
1681
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
861 address addr = (address)x; |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
862 CodeBlob* b = CodeCache::find_blob_unsafe(addr); |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
863 if (b != NULL) { |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
864 if (b->is_buffer_blob()) { |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
865 // the interpreter is generated into a buffer blob |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
866 InterpreterCodelet* i = Interpreter::codelet_containing(addr); |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
867 if (i != NULL) { |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6197
diff
changeset
|
868 st->print_cr(INTPTR_FORMAT " is at code_begin+%d in an Interpreter codelet", addr, (int)(addr - i->code_begin())); |
|
1681
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
869 i->print_on(st); |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
870 return; |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
871 } |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
872 if (Interpreter::contains(addr)) { |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
873 st->print_cr(INTPTR_FORMAT " is pointing into interpreter code" |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
874 " (not bytecode specific)", addr); |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
875 return; |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
876 } |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
877 // |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
878 if (AdapterHandlerLibrary::contains(b)) { |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6197
diff
changeset
|
879 st->print_cr(INTPTR_FORMAT " is at code_begin+%d in an AdapterHandler", addr, (int)(addr - b->code_begin())); |
|
1681
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
880 AdapterHandlerLibrary::print_handler_on(st, b); |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
881 } |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
882 // the stubroutines are generated into a buffer blob |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
883 StubCodeDesc* d = StubCodeDesc::desc_for(addr); |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
884 if (d != NULL) { |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6197
diff
changeset
|
885 st->print_cr(INTPTR_FORMAT " is at begin+%d in a stub", addr, (int)(addr - d->begin())); |
|
1681
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
886 d->print_on(st); |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6197
diff
changeset
|
887 st->cr(); |
|
1681
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
888 return; |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
889 } |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
890 if (StubRoutines::contains(addr)) { |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
891 st->print_cr(INTPTR_FORMAT " is pointing to an (unnamed) " |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
892 "stub routine", addr); |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
893 return; |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
894 } |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
895 // the InlineCacheBuffer is using stubs generated into a buffer blob |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
896 if (InlineCacheBuffer::contains(addr)) { |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
897 st->print_cr(INTPTR_FORMAT " is pointing into InlineCacheBuffer", addr); |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
898 return; |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
899 } |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
900 VtableStub* v = VtableStubs::stub_containing(addr); |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
901 if (v != NULL) { |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6197
diff
changeset
|
902 st->print_cr(INTPTR_FORMAT " is at entry_point+%d in a vtable stub", addr, (int)(addr - v->entry_point())); |
|
1681
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
903 v->print_on(st); |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6197
diff
changeset
|
904 st->cr(); |
|
1681
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
905 return; |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
906 } |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
907 } |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6197
diff
changeset
|
908 nmethod* nm = b->as_nmethod_or_null(); |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6197
diff
changeset
|
909 if (nm != NULL) { |
|
1681
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
910 ResourceMark rm; |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6197
diff
changeset
|
911 st->print(INTPTR_FORMAT " is at entry_point+%d in (nmethod*)" INTPTR_FORMAT, |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6197
diff
changeset
|
912 addr, (int)(addr - nm->entry_point()), nm); |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6197
diff
changeset
|
913 if (verbose) { |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6197
diff
changeset
|
914 st->print(" for "); |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6197
diff
changeset
|
915 nm->method()->print_value_on(st); |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6197
diff
changeset
|
916 } |
|
6816
87ac5c0a404d
8000228: Missing call to cr() when printing entry_point in nmethod, in os::print_location
stefank
parents:
6814
diff
changeset
|
917 st->cr(); |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6197
diff
changeset
|
918 nm->print_nmethod(verbose); |
|
1681
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
919 return; |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
920 } |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6197
diff
changeset
|
921 st->print_cr(INTPTR_FORMAT " is at code_begin+%d in ", addr, (int)(addr - b->code_begin())); |
|
1681
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
922 b->print_on(st); |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
923 return; |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
924 } |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
925 |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
926 if (Universe::heap()->is_in(addr)) { |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
927 HeapWord* p = Universe::heap()->block_start(addr); |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
928 bool print = false; |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
929 // If we couldn't find it it just may mean that heap wasn't parseable |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
930 // See if we were just given an oop directly |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
931 if (p != NULL && Universe::heap()->block_is_obj(p)) { |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
932 print = true; |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
933 } else if (p == NULL && ((oopDesc*)addr)->is_oop()) { |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
934 p = (HeapWord*) addr; |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
935 print = true; |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
936 } |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
937 if (print) { |
|
6814
85f1cded9793
8000230: Change os::print_location to be more descriptive when a location is pointing into an object
stefank
parents:
6766
diff
changeset
|
938 if (p == (HeapWord*) addr) { |
|
85f1cded9793
8000230: Change os::print_location to be more descriptive when a location is pointing into an object
stefank
parents:
6766
diff
changeset
|
939 st->print_cr(INTPTR_FORMAT " is an oop", addr); |
|
85f1cded9793
8000230: Change os::print_location to be more descriptive when a location is pointing into an object
stefank
parents:
6766
diff
changeset
|
940 } else { |
|
85f1cded9793
8000230: Change os::print_location to be more descriptive when a location is pointing into an object
stefank
parents:
6766
diff
changeset
|
941 st->print_cr(INTPTR_FORMAT " is pointing into object: " INTPTR_FORMAT, addr, p); |
|
85f1cded9793
8000230: Change os::print_location to be more descriptive when a location is pointing into an object
stefank
parents:
6766
diff
changeset
|
942 } |
|
1681
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
943 oop(p)->print_on(st); |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
944 return; |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
945 } |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
946 } else { |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
947 if (Universe::heap()->is_in_reserved(addr)) { |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
948 st->print_cr(INTPTR_FORMAT " is an unallocated location " |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
949 "in the heap", addr); |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
950 return; |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
951 } |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
952 } |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
953 if (JNIHandles::is_global_handle((jobject) addr)) { |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
954 st->print_cr(INTPTR_FORMAT " is a global jni handle", addr); |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
955 return; |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
956 } |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
957 if (JNIHandles::is_weak_global_handle((jobject) addr)) { |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
958 st->print_cr(INTPTR_FORMAT " is a weak global jni handle", addr); |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
959 return; |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
960 } |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
961 #ifndef PRODUCT |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
962 // we don't keep the block list in product mode |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
963 if (JNIHandleBlock::any_contains((jobject) addr)) { |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
964 st->print_cr(INTPTR_FORMAT " is a local jni handle", addr); |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
965 return; |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
966 } |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
967 #endif |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
968 |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
969 for(JavaThread *thread = Threads::first(); thread; thread = thread->next()) { |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
970 // Check for privilege stack |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
971 if (thread->privileged_stack_top() != NULL && |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
972 thread->privileged_stack_top()->contains(addr)) { |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
973 st->print_cr(INTPTR_FORMAT " is pointing into the privilege stack " |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
974 "for thread: " INTPTR_FORMAT, addr, thread); |
| 1907 | 975 if (verbose) thread->print_on(st); |
|
1681
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
976 return; |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
977 } |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
978 // If the addr is a java thread print information about that. |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
979 if (addr == (address)thread) { |
| 1907 | 980 if (verbose) { |
| 981 thread->print_on(st); | |
| 982 } else { | |
| 983 st->print_cr(INTPTR_FORMAT " is a thread", addr); | |
| 984 } | |
|
1681
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
985 return; |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
986 } |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
987 // If the addr is in the stack region for this thread then report that |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
988 // and print thread info |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
989 if (thread->stack_base() >= addr && |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
990 addr > (thread->stack_base() - thread->stack_size())) { |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
991 st->print_cr(INTPTR_FORMAT " is pointing into the stack for thread: " |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
992 INTPTR_FORMAT, addr, thread); |
| 1907 | 993 if (verbose) thread->print_on(st); |
|
1681
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
994 return; |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
995 } |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
996 |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
997 } |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
998 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
999 #ifndef PRODUCT |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1000 // Check if in metaspace. |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1001 if (ClassLoaderDataGraph::contains((address)addr)) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1002 // Use addr->print() from the debugger instead (not here) |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1003 st->print_cr(INTPTR_FORMAT |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1004 " is pointing into metadata", addr); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1005 return; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1006 } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1007 #endif |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1008 |
|
1681
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
1009 // Try an OS specific find |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
1010 if (os::find(addr, st)) { |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
1011 return; |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
1012 } |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
1013 |
| 1907 | 1014 st->print_cr(INTPTR_FORMAT " is an unknown value", addr); |
|
1681
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
1015 } |
| 0 | 1016 |
| 1017 // Looks like all platforms except IA64 can use the same function to check | |
| 1018 // if C stack is walkable beyond current frame. The check for fp() is not | |
| 1019 // necessary on Sparc, but it's harmless. | |
| 1020 bool os::is_first_C_frame(frame* fr) { | |
| 7994 | 1021 #if defined(IA64) && !defined(_WIN32) |
| 1022 // On IA64 we have to check if the callers bsp is still valid | |
| 1023 // (i.e. within the register stack bounds). | |
| 1024 // Notice: this only works for threads created by the VM and only if | |
| 1025 // we walk the current stack!!! If we want to be able to walk | |
| 1026 // arbitrary other threads, we'll have to somehow store the thread | |
| 1027 // object in the frame. | |
| 1028 Thread *thread = Thread::current(); | |
| 1029 if ((address)fr->fp() <= | |
| 1030 thread->register_stack_base() HPUX_ONLY(+ 0x0) LINUX_ONLY(+ 0x50)) { | |
| 1031 // This check is a little hacky, because on Linux the first C | |
| 1032 // frame's ('start_thread') register stack frame starts at | |
| 1033 // "register_stack_base + 0x48" while on HPUX, the first C frame's | |
| 1034 // ('__pthread_bound_body') register stack frame seems to really | |
| 1035 // start at "register_stack_base". | |
| 1036 return true; | |
| 1037 } else { | |
| 1038 return false; | |
| 1039 } | |
| 1040 #elif defined(IA64) && defined(_WIN32) | |
| 0 | 1041 return true; |
| 7994 | 1042 #else |
| 0 | 1043 // Load up sp, fp, sender sp and sender fp, check for reasonable values. |
| 1044 // Check usp first, because if that's bad the other accessors may fault | |
| 1045 // on some architectures. Ditto ufp second, etc. | |
| 1046 uintptr_t fp_align_mask = (uintptr_t)(sizeof(address)-1); | |
| 1047 // sp on amd can be 32 bit aligned. | |
| 1048 uintptr_t sp_align_mask = (uintptr_t)(sizeof(int)-1); | |
| 1049 | |
| 1050 uintptr_t usp = (uintptr_t)fr->sp(); | |
| 1051 if ((usp & sp_align_mask) != 0) return true; | |
| 1052 | |
| 1053 uintptr_t ufp = (uintptr_t)fr->fp(); | |
| 1054 if ((ufp & fp_align_mask) != 0) return true; | |
| 1055 | |
| 1056 uintptr_t old_sp = (uintptr_t)fr->sender_sp(); | |
| 1057 if ((old_sp & sp_align_mask) != 0) return true; | |
| 1058 if (old_sp == 0 || old_sp == (uintptr_t)-1) return true; | |
| 1059 | |
| 1060 uintptr_t old_fp = (uintptr_t)fr->link(); | |
| 1061 if ((old_fp & fp_align_mask) != 0) return true; | |
| 1062 if (old_fp == 0 || old_fp == (uintptr_t)-1 || old_fp == ufp) return true; | |
| 1063 | |
| 1064 // stack grows downwards; if old_fp is below current fp or if the stack | |
| 1065 // frame is too large, either the stack is corrupted or fp is not saved | |
| 1066 // on stack (i.e. on x86, ebp may be used as general register). The stack | |
| 1067 // is not walkable beyond current frame. | |
| 1068 if (old_fp < ufp) return true; | |
| 1069 if (old_fp - ufp > 64 * K) return true; | |
| 1070 | |
| 1071 return false; | |
| 7994 | 1072 #endif |
| 0 | 1073 } |
| 1074 | |
| 1075 #ifdef ASSERT | |
| 1076 extern "C" void test_random() { | |
| 1077 const double m = 2147483647; | |
| 1078 double mean = 0.0, variance = 0.0, t; | |
| 1079 long reps = 10000; | |
| 1080 unsigned long seed = 1; | |
| 1081 | |
| 1082 tty->print_cr("seed %ld for %ld repeats...", seed, reps); | |
| 1083 os::init_random(seed); | |
| 1084 long num; | |
| 1085 for (int k = 0; k < reps; k++) { | |
| 1086 num = os::random(); | |
| 1087 double u = (double)num / m; | |
| 1088 assert(u >= 0.0 && u <= 1.0, "bad random number!"); | |
| 1089 | |
| 1090 // calculate mean and variance of the random sequence | |
| 1091 mean += u; | |
| 1092 variance += (u*u); | |
| 1093 } | |
| 1094 mean /= reps; | |
| 1095 variance /= (reps - 1); | |
| 1096 | |
| 1097 assert(num == 1043618065, "bad seed"); | |
| 1098 tty->print_cr("mean of the 1st 10000 numbers: %f", mean); | |
| 1099 tty->print_cr("variance of the 1st 10000 numbers: %f", variance); | |
| 1100 const double eps = 0.0001; | |
| 1101 t = fabsd(mean - 0.5018); | |
| 1102 assert(t < eps, "bad mean"); | |
| 1103 t = (variance - 0.3355) < 0.0 ? -(variance - 0.3355) : variance - 0.3355; | |
| 1104 assert(t < eps, "bad variance"); | |
| 1105 } | |
| 1106 #endif | |
| 1107 | |
| 1108 | |
| 1109 // Set up the boot classpath. | |
| 1110 | |
| 1111 char* os::format_boot_path(const char* format_string, | |
| 1112 const char* home, | |
| 1113 int home_len, | |
| 1114 char fileSep, | |
| 1115 char pathSep) { | |
| 1116 assert((fileSep == '/' && pathSep == ':') || | |
| 1117 (fileSep == '\\' && pathSep == ';'), "unexpected seperator chars"); | |
| 1118 | |
| 1119 // Scan the format string to determine the length of the actual | |
| 1120 // boot classpath, and handle platform dependencies as well. | |
| 1121 int formatted_path_len = 0; | |
| 1122 const char* p; | |
| 1123 for (p = format_string; *p != 0; ++p) { | |
| 1124 if (*p == '%') formatted_path_len += home_len - 1; | |
| 1125 ++formatted_path_len; | |
| 1126 } | |
| 1127 | |
| 6197 | 1128 char* formatted_path = NEW_C_HEAP_ARRAY(char, formatted_path_len + 1, mtInternal); |
| 0 | 1129 if (formatted_path == NULL) { |
| 1130 return NULL; | |
| 1131 } | |
| 1132 | |
| 1133 // Create boot classpath from format, substituting separator chars and | |
| 1134 // java home directory. | |
| 1135 char* q = formatted_path; | |
| 1136 for (p = format_string; *p != 0; ++p) { | |
| 1137 switch (*p) { | |
| 1138 case '%': | |
| 1139 strcpy(q, home); | |
| 1140 q += home_len; | |
| 1141 break; | |
| 1142 case '/': | |
| 1143 *q++ = fileSep; | |
| 1144 break; | |
| 1145 case ':': | |
| 1146 *q++ = pathSep; | |
| 1147 break; | |
| 1148 default: | |
| 1149 *q++ = *p; | |
| 1150 } | |
| 1151 } | |
| 1152 *q = '\0'; | |
| 1153 | |
| 1154 assert((q - formatted_path) == formatted_path_len, "formatted_path size botched"); | |
| 1155 return formatted_path; | |
| 1156 } | |
| 1157 | |
| 1158 | |
| 1159 bool os::set_boot_path(char fileSep, char pathSep) { | |
| 1160 const char* home = Arguments::get_java_home(); | |
| 1161 int home_len = (int)strlen(home); | |
| 1162 | |
| 1163 static const char* meta_index_dir_format = "%/lib/"; | |
| 1164 static const char* meta_index_format = "%/lib/meta-index"; | |
| 1165 char* meta_index = format_boot_path(meta_index_format, home, home_len, fileSep, pathSep); | |
| 1166 if (meta_index == NULL) return false; | |
| 1167 char* meta_index_dir = format_boot_path(meta_index_dir_format, home, home_len, fileSep, pathSep); | |
| 1168 if (meta_index_dir == NULL) return false; | |
| 1169 Arguments::set_meta_index_path(meta_index, meta_index_dir); | |
| 1170 | |
| 1171 // Any modification to the JAR-file list, for the boot classpath must be | |
| 1172 // aligned with install/install/make/common/Pack.gmk. Note: boot class | |
| 1173 // path class JARs, are stripped for StackMapTable to reduce download size. | |
| 1174 static const char classpath_format[] = | |
| 1175 "%/lib/resources.jar:" | |
| 1176 "%/lib/rt.jar:" | |
| 1177 "%/lib/sunrsasign.jar:" | |
| 1178 "%/lib/jsse.jar:" | |
| 1179 "%/lib/jce.jar:" | |
| 1180 "%/lib/charsets.jar:" | |
|
4800
94ec88ca68e2
7115199: Add event tracing hooks and Java Flight Recorder infrastructure
phh
parents:
4749
diff
changeset
|
1181 "%/lib/jfr.jar:" |
| 4006 | 1182 #ifdef __APPLE__ |
| 1183 "%/lib/JObjC.jar:" | |
| 1184 #endif | |
| 0 | 1185 "%/classes"; |
| 1186 char* sysclasspath = format_boot_path(classpath_format, home, home_len, fileSep, pathSep); | |
| 1187 if (sysclasspath == NULL) return false; | |
| 1188 Arguments::set_sysclasspath(sysclasspath); | |
| 1189 | |
| 1190 return true; | |
| 1191 } | |
| 1192 | |
| 691 | 1193 /* |
| 1194 * Splits a path, based on its separator, the number of | |
| 1195 * elements is returned back in n. | |
| 1196 * It is the callers responsibility to: | |
| 1197 * a> check the value of n, and n may be 0. | |
| 1198 * b> ignore any empty path elements | |
| 1199 * c> free up the data. | |
| 1200 */ | |
| 1201 char** os::split_path(const char* path, int* n) { | |
| 1202 *n = 0; | |
| 1203 if (path == NULL || strlen(path) == 0) { | |
| 1204 return NULL; | |
| 1205 } | |
| 1206 const char psepchar = *os::path_separator(); | |
| 6197 | 1207 char* inpath = (char*)NEW_C_HEAP_ARRAY(char, strlen(path) + 1, mtInternal); |
| 691 | 1208 if (inpath == NULL) { |
| 1209 return NULL; | |
| 1210 } | |
|
6966
6cb0d32b828b
8001185: parsing of sun.boot.library.path in os::dll_build_name somewhat broken
bpittore
parents:
6882
diff
changeset
|
1211 strcpy(inpath, path); |
| 691 | 1212 int count = 1; |
| 1213 char* p = strchr(inpath, psepchar); | |
| 1214 // Get a count of elements to allocate memory | |
| 1215 while (p != NULL) { | |
| 1216 count++; | |
| 1217 p++; | |
| 1218 p = strchr(p, psepchar); | |
| 1219 } | |
| 6197 | 1220 char** opath = (char**) NEW_C_HEAP_ARRAY(char*, count, mtInternal); |
| 691 | 1221 if (opath == NULL) { |
| 1222 return NULL; | |
| 1223 } | |
| 1224 | |
| 1225 // do the actual splitting | |
| 1226 p = inpath; | |
| 1227 for (int i = 0 ; i < count ; i++) { | |
| 1228 size_t len = strcspn(p, os::path_separator()); | |
| 1229 if (len > JVM_MAXPATHLEN) { | |
| 1230 return NULL; | |
| 1231 } | |
| 1232 // allocate the string and add terminator storage | |
| 6197 | 1233 char* s = (char*)NEW_C_HEAP_ARRAY(char, len + 1, mtInternal); |
| 691 | 1234 if (s == NULL) { |
| 1235 return NULL; | |
| 1236 } | |
| 1237 strncpy(s, p, len); | |
| 1238 s[len] = '\0'; | |
| 1239 opath[i] = s; | |
| 1240 p += len + 1; | |
| 1241 } | |
| 6197 | 1242 FREE_C_HEAP_ARRAY(char, inpath, mtInternal); |
| 691 | 1243 *n = count; |
| 1244 return opath; | |
| 1245 } | |
| 1246 | |
| 0 | 1247 void os::set_memory_serialize_page(address page) { |
| 1248 int count = log2_intptr(sizeof(class JavaThread)) - log2_intptr(64); | |
| 1249 _mem_serialize_page = (volatile int32_t *)page; | |
| 1250 // We initialize the serialization page shift count here | |
| 1251 // We assume a cache line size of 64 bytes | |
| 1252 assert(SerializePageShiftCount == count, | |
| 1253 "thread size changed, fix SerializePageShiftCount constant"); | |
| 1254 set_serialize_page_mask((uintptr_t)(vm_page_size() - sizeof(int32_t))); | |
| 1255 } | |
| 1256 | |
|
55
2a8eb116ebbe
6610420: Debug VM crashes during monitor lock rank checking
xlu
parents:
0
diff
changeset
|
1257 static volatile intptr_t SerializePageLock = 0; |
|
2a8eb116ebbe
6610420: Debug VM crashes during monitor lock rank checking
xlu
parents:
0
diff
changeset
|
1258 |
| 0 | 1259 // This method is called from signal handler when SIGSEGV occurs while the current |
| 1260 // thread tries to store to the "read-only" memory serialize page during state | |
| 1261 // transition. | |
| 1262 void os::block_on_serialize_page_trap() { | |
| 1263 if (TraceSafepoint) { | |
| 1264 tty->print_cr("Block until the serialize page permission restored"); | |
| 1265 } | |
|
55
2a8eb116ebbe
6610420: Debug VM crashes during monitor lock rank checking
xlu
parents:
0
diff
changeset
|
1266 // When VMThread is holding the SerializePageLock during modifying the |
| 0 | 1267 // access permission of the memory serialize page, the following call |
| 1268 // will block until the permission of that page is restored to rw. | |
| 1269 // Generally, it is unsafe to manipulate locks in signal handlers, but in | |
| 1270 // this case, it's OK as the signal is synchronous and we know precisely when | |
|
55
2a8eb116ebbe
6610420: Debug VM crashes during monitor lock rank checking
xlu
parents:
0
diff
changeset
|
1271 // it can occur. |
|
2a8eb116ebbe
6610420: Debug VM crashes during monitor lock rank checking
xlu
parents:
0
diff
changeset
|
1272 Thread::muxAcquire(&SerializePageLock, "set_memory_serialize_page"); |
|
2a8eb116ebbe
6610420: Debug VM crashes during monitor lock rank checking
xlu
parents:
0
diff
changeset
|
1273 Thread::muxRelease(&SerializePageLock); |
| 0 | 1274 } |
| 1275 | |
| 1276 // Serialize all thread state variables | |
| 1277 void os::serialize_thread_states() { | |
| 1278 // On some platforms such as Solaris & Linux, the time duration of the page | |
| 1279 // permission restoration is observed to be much longer than expected due to | |
| 1280 // scheduler starvation problem etc. To avoid the long synchronization | |
|
55
2a8eb116ebbe
6610420: Debug VM crashes during monitor lock rank checking
xlu
parents:
0
diff
changeset
|
1281 // time and expensive page trap spinning, 'SerializePageLock' is used to block |
|
2a8eb116ebbe
6610420: Debug VM crashes during monitor lock rank checking
xlu
parents:
0
diff
changeset
|
1282 // the mutator thread if such case is encountered. See bug 6546278 for details. |
|
2a8eb116ebbe
6610420: Debug VM crashes during monitor lock rank checking
xlu
parents:
0
diff
changeset
|
1283 Thread::muxAcquire(&SerializePageLock, "serialize_thread_states"); |
|
237
1fdb98a17101
6716785: implicit null checks not triggering with CompressedOops
coleenp
parents:
196
diff
changeset
|
1284 os::protect_memory((char *)os::get_memory_serialize_page(), |
|
477
24fda36852ce
6727377: VM stack guard pages on Windows should PAGE_READWRITE not PAGE_EXECUTE_READWRITE
coleenp
parents:
242
diff
changeset
|
1285 os::vm_page_size(), MEM_PROT_READ); |
|
24fda36852ce
6727377: VM stack guard pages on Windows should PAGE_READWRITE not PAGE_EXECUTE_READWRITE
coleenp
parents:
242
diff
changeset
|
1286 os::protect_memory((char *)os::get_memory_serialize_page(), |
|
24fda36852ce
6727377: VM stack guard pages on Windows should PAGE_READWRITE not PAGE_EXECUTE_READWRITE
coleenp
parents:
242
diff
changeset
|
1287 os::vm_page_size(), MEM_PROT_RW); |
|
55
2a8eb116ebbe
6610420: Debug VM crashes during monitor lock rank checking
xlu
parents:
0
diff
changeset
|
1288 Thread::muxRelease(&SerializePageLock); |
| 0 | 1289 } |
| 1290 | |
| 1291 // Returns true if the current stack pointer is above the stack shadow | |
| 1292 // pages, false otherwise. | |
| 1293 | |
| 1294 bool os::stack_shadow_pages_available(Thread *thread, methodHandle method) { | |
| 1295 assert(StackRedPages > 0 && StackYellowPages > 0,"Sanity check"); | |
| 1296 address sp = current_stack_pointer(); | |
| 1297 // Check if we have StackShadowPages above the yellow zone. This parameter | |
| 605 | 1298 // is dependent on the depth of the maximum VM call stack possible from |
| 0 | 1299 // the handler for stack overflow. 'instanceof' in the stack overflow |
| 1300 // handler or a println uses at least 8k stack of VM and native code | |
| 1301 // respectively. | |
| 1302 const int framesize_in_bytes = | |
| 1303 Interpreter::size_top_interpreter_activation(method()) * wordSize; | |
| 1304 int reserved_area = ((StackShadowPages + StackRedPages + StackYellowPages) | |
| 1305 * vm_page_size()) + framesize_in_bytes; | |
| 1306 // The very lower end of the stack | |
| 1307 address stack_limit = thread->stack_base() - thread->stack_size(); | |
| 1308 return (sp > (stack_limit + reserved_area)); | |
| 1309 } | |
| 1310 | |
| 1311 size_t os::page_size_for_region(size_t region_min_size, size_t region_max_size, | |
| 1312 uint min_pages) | |
| 1313 { | |
| 1314 assert(min_pages > 0, "sanity"); | |
| 1315 if (UseLargePages) { | |
| 1316 const size_t max_page_size = region_max_size / min_pages; | |
| 1317 | |
| 1318 for (unsigned int i = 0; _page_sizes[i] != 0; ++i) { | |
| 1319 const size_t sz = _page_sizes[i]; | |
| 1320 const size_t mask = sz - 1; | |
| 1321 if ((region_min_size & mask) == 0 && (region_max_size & mask) == 0) { | |
| 1322 // The largest page size with no fragmentation. | |
| 1323 return sz; | |
| 1324 } | |
| 1325 | |
| 1326 if (sz <= max_page_size) { | |
| 1327 // The largest page size that satisfies the min_pages requirement. | |
| 1328 return sz; | |
| 1329 } | |
| 1330 } | |
| 1331 } | |
| 1332 | |
| 1333 return vm_page_size(); | |
| 1334 } | |
| 1335 | |
| 1336 #ifndef PRODUCT | |
| 3859 | 1337 void os::trace_page_sizes(const char* str, const size_t* page_sizes, int count) |
| 1338 { | |
| 1339 if (TracePageSizes) { | |
| 1340 tty->print("%s: ", str); | |
| 1341 for (int i = 0; i < count; ++i) { | |
| 1342 tty->print(" " SIZE_FORMAT, page_sizes[i]); | |
| 1343 } | |
| 1344 tty->cr(); | |
| 1345 } | |
| 1346 } | |
| 1347 | |
| 0 | 1348 void os::trace_page_sizes(const char* str, const size_t region_min_size, |
| 1349 const size_t region_max_size, const size_t page_size, | |
| 1350 const char* base, const size_t size) | |
| 1351 { | |
| 1352 if (TracePageSizes) { | |
| 1353 tty->print_cr("%s: min=" SIZE_FORMAT " max=" SIZE_FORMAT | |
| 1354 " pg_sz=" SIZE_FORMAT " base=" PTR_FORMAT | |
| 1355 " size=" SIZE_FORMAT, | |
| 1356 str, region_min_size, region_max_size, | |
| 1357 page_size, base, size); | |
| 1358 } | |
| 1359 } | |
| 1360 #endif // #ifndef PRODUCT | |
| 1361 | |
| 1362 // This is the working definition of a server class machine: | |
| 1363 // >= 2 physical CPU's and >=2GB of memory, with some fuzz | |
| 1364 // because the graphics memory (?) sometimes masks physical memory. | |
| 1365 // If you want to change the definition of a server class machine | |
| 1366 // on some OS or platform, e.g., >=4GB on Windohs platforms, | |
| 1367 // then you'll have to parameterize this method based on that state, | |
| 1368 // as was done for logical processors here, or replicate and | |
| 1369 // specialize this method for each platform. (Or fix os to have | |
| 1370 // some inheritance structure and use subclassing. Sigh.) | |
| 1371 // If you want some platform to always or never behave as a server | |
| 1372 // class machine, change the setting of AlwaysActAsServerClassMachine | |
| 1373 // and NeverActAsServerClassMachine in globals*.hpp. | |
| 1374 bool os::is_server_class_machine() { | |
| 1375 // First check for the early returns | |
| 1376 if (NeverActAsServerClassMachine) { | |
| 1377 return false; | |
| 1378 } | |
| 1379 if (AlwaysActAsServerClassMachine) { | |
| 1380 return true; | |
| 1381 } | |
| 1382 // Then actually look at the machine | |
| 1383 bool result = false; | |
| 1384 const unsigned int server_processors = 2; | |
| 1385 const julong server_memory = 2UL * G; | |
| 1386 // We seem not to get our full complement of memory. | |
| 1387 // We allow some part (1/8?) of the memory to be "missing", | |
| 1388 // based on the sizes of DIMMs, and maybe graphics cards. | |
| 1389 const julong missing_memory = 256UL * M; | |
| 1390 | |
| 1391 /* Is this a server class machine? */ | |
| 1392 if ((os::active_processor_count() >= (int)server_processors) && | |
| 1393 (os::physical_memory() >= (server_memory - missing_memory))) { | |
| 1394 const unsigned int logical_processors = | |
| 1395 VM_Version::logical_processors_per_package(); | |
| 1396 if (logical_processors > 1) { | |
| 1397 const unsigned int physical_packages = | |
| 1398 os::active_processor_count() / logical_processors; | |
| 1399 if (physical_packages > server_processors) { | |
| 1400 result = true; | |
| 1401 } | |
| 1402 } else { | |
| 1403 result = true; | |
| 1404 } | |
| 1405 } | |
| 1406 return result; | |
| 1407 } | |
|
2469
677234770800
7017193: Small memory leak in get_stack_bounds os::create_stack_guard_pages
dsamersoff
parents:
2387
diff
changeset
|
1408 |
|
677234770800
7017193: Small memory leak in get_stack_bounds os::create_stack_guard_pages
dsamersoff
parents:
2387
diff
changeset
|
1409 // Read file line by line, if line is longer than bsize, |
|
677234770800
7017193: Small memory leak in get_stack_bounds os::create_stack_guard_pages
dsamersoff
parents:
2387
diff
changeset
|
1410 // skip rest of line. |
|
677234770800
7017193: Small memory leak in get_stack_bounds os::create_stack_guard_pages
dsamersoff
parents:
2387
diff
changeset
|
1411 int os::get_line_chars(int fd, char* buf, const size_t bsize){ |
|
677234770800
7017193: Small memory leak in get_stack_bounds os::create_stack_guard_pages
dsamersoff
parents:
2387
diff
changeset
|
1412 size_t sz, i = 0; |
|
677234770800
7017193: Small memory leak in get_stack_bounds os::create_stack_guard_pages
dsamersoff
parents:
2387
diff
changeset
|
1413 |
|
677234770800
7017193: Small memory leak in get_stack_bounds os::create_stack_guard_pages
dsamersoff
parents:
2387
diff
changeset
|
1414 // read until EOF, EOL or buf is full |
| 3832 | 1415 while ((sz = (int) read(fd, &buf[i], 1)) == 1 && i < (bsize-2) && buf[i] != '\n') { |
|
2469
677234770800
7017193: Small memory leak in get_stack_bounds os::create_stack_guard_pages
dsamersoff
parents:
2387
diff
changeset
|
1416 ++i; |
|
677234770800
7017193: Small memory leak in get_stack_bounds os::create_stack_guard_pages
dsamersoff
parents:
2387
diff
changeset
|
1417 } |
|
677234770800
7017193: Small memory leak in get_stack_bounds os::create_stack_guard_pages
dsamersoff
parents:
2387
diff
changeset
|
1418 |
|
677234770800
7017193: Small memory leak in get_stack_bounds os::create_stack_guard_pages
dsamersoff
parents:
2387
diff
changeset
|
1419 if (buf[i] == '\n') { |
|
677234770800
7017193: Small memory leak in get_stack_bounds os::create_stack_guard_pages
dsamersoff
parents:
2387
diff
changeset
|
1420 // EOL reached so ignore EOL character and return |
|
677234770800
7017193: Small memory leak in get_stack_bounds os::create_stack_guard_pages
dsamersoff
parents:
2387
diff
changeset
|
1421 |
|
677234770800
7017193: Small memory leak in get_stack_bounds os::create_stack_guard_pages
dsamersoff
parents:
2387
diff
changeset
|
1422 buf[i] = 0; |
|
677234770800
7017193: Small memory leak in get_stack_bounds os::create_stack_guard_pages
dsamersoff
parents:
2387
diff
changeset
|
1423 return (int) i; |
|
677234770800
7017193: Small memory leak in get_stack_bounds os::create_stack_guard_pages
dsamersoff
parents:
2387
diff
changeset
|
1424 } |
|
677234770800
7017193: Small memory leak in get_stack_bounds os::create_stack_guard_pages
dsamersoff
parents:
2387
diff
changeset
|
1425 |
|
677234770800
7017193: Small memory leak in get_stack_bounds os::create_stack_guard_pages
dsamersoff
parents:
2387
diff
changeset
|
1426 buf[i+1] = 0; |
|
677234770800
7017193: Small memory leak in get_stack_bounds os::create_stack_guard_pages
dsamersoff
parents:
2387
diff
changeset
|
1427 |
|
677234770800
7017193: Small memory leak in get_stack_bounds os::create_stack_guard_pages
dsamersoff
parents:
2387
diff
changeset
|
1428 if (sz != 1) { |
|
677234770800
7017193: Small memory leak in get_stack_bounds os::create_stack_guard_pages
dsamersoff
parents:
2387
diff
changeset
|
1429 // EOF reached. if we read chars before EOF return them and |
|
677234770800
7017193: Small memory leak in get_stack_bounds os::create_stack_guard_pages
dsamersoff
parents:
2387
diff
changeset
|
1430 // return EOF on next call otherwise return EOF |
|
677234770800
7017193: Small memory leak in get_stack_bounds os::create_stack_guard_pages
dsamersoff
parents:
2387
diff
changeset
|
1431 |
|
677234770800
7017193: Small memory leak in get_stack_bounds os::create_stack_guard_pages
dsamersoff
parents:
2387
diff
changeset
|
1432 return (i == 0) ? -1 : (int) i; |
|
677234770800
7017193: Small memory leak in get_stack_bounds os::create_stack_guard_pages
dsamersoff
parents:
2387
diff
changeset
|
1433 } |
|
677234770800
7017193: Small memory leak in get_stack_bounds os::create_stack_guard_pages
dsamersoff
parents:
2387
diff
changeset
|
1434 |
|
677234770800
7017193: Small memory leak in get_stack_bounds os::create_stack_guard_pages
dsamersoff
parents:
2387
diff
changeset
|
1435 // line is longer than size of buf, skip to EOL |
| 3832 | 1436 char ch; |
|
2469
677234770800
7017193: Small memory leak in get_stack_bounds os::create_stack_guard_pages
dsamersoff
parents:
2387
diff
changeset
|
1437 while (read(fd, &ch, 1) == 1 && ch != '\n') { |
|
677234770800
7017193: Small memory leak in get_stack_bounds os::create_stack_guard_pages
dsamersoff
parents:
2387
diff
changeset
|
1438 // Do nothing |
|
677234770800
7017193: Small memory leak in get_stack_bounds os::create_stack_guard_pages
dsamersoff
parents:
2387
diff
changeset
|
1439 } |
|
677234770800
7017193: Small memory leak in get_stack_bounds os::create_stack_guard_pages
dsamersoff
parents:
2387
diff
changeset
|
1440 |
|
677234770800
7017193: Small memory leak in get_stack_bounds os::create_stack_guard_pages
dsamersoff
parents:
2387
diff
changeset
|
1441 // return initial part of line that fits in buf. |
|
677234770800
7017193: Small memory leak in get_stack_bounds os::create_stack_guard_pages
dsamersoff
parents:
2387
diff
changeset
|
1442 // If we reached EOF, it will be returned on next call. |
|
677234770800
7017193: Small memory leak in get_stack_bounds os::create_stack_guard_pages
dsamersoff
parents:
2387
diff
changeset
|
1443 |
|
677234770800
7017193: Small memory leak in get_stack_bounds os::create_stack_guard_pages
dsamersoff
parents:
2387
diff
changeset
|
1444 return (int) i; |
|
677234770800
7017193: Small memory leak in get_stack_bounds os::create_stack_guard_pages
dsamersoff
parents:
2387
diff
changeset
|
1445 } |
| 6197 | 1446 |
| 1447 bool os::create_stack_guard_pages(char* addr, size_t bytes) { | |
| 1448 return os::pd_create_stack_guard_pages(addr, bytes); | |
| 1449 } | |
| 1450 | |
| 1451 | |
| 1452 char* os::reserve_memory(size_t bytes, char* addr, size_t alignment_hint) { | |
| 1453 char* result = pd_reserve_memory(bytes, addr, alignment_hint); | |
|
6882
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6816
diff
changeset
|
1454 if (result != NULL) { |
| 6197 | 1455 MemTracker::record_virtual_memory_reserve((address)result, bytes, CALLER_PC); |
| 1456 } | |
| 1457 | |
| 1458 return result; | |
| 1459 } | |
|
10221
c18152e0554e
8013120: NMT: Kitchensink crashes with assert(next_region == NULL || !next_region->is_committed_region()) failed: Sanity check
zgu
parents:
8808
diff
changeset
|
1460 |
|
c18152e0554e
8013120: NMT: Kitchensink crashes with assert(next_region == NULL || !next_region->is_committed_region()) failed: Sanity check
zgu
parents:
8808
diff
changeset
|
1461 char* os::reserve_memory(size_t bytes, char* addr, size_t alignment_hint, |
|
c18152e0554e
8013120: NMT: Kitchensink crashes with assert(next_region == NULL || !next_region->is_committed_region()) failed: Sanity check
zgu
parents:
8808
diff
changeset
|
1462 MEMFLAGS flags) { |
|
c18152e0554e
8013120: NMT: Kitchensink crashes with assert(next_region == NULL || !next_region->is_committed_region()) failed: Sanity check
zgu
parents:
8808
diff
changeset
|
1463 char* result = pd_reserve_memory(bytes, addr, alignment_hint); |
|
c18152e0554e
8013120: NMT: Kitchensink crashes with assert(next_region == NULL || !next_region->is_committed_region()) failed: Sanity check
zgu
parents:
8808
diff
changeset
|
1464 if (result != NULL) { |
|
c18152e0554e
8013120: NMT: Kitchensink crashes with assert(next_region == NULL || !next_region->is_committed_region()) failed: Sanity check
zgu
parents:
8808
diff
changeset
|
1465 MemTracker::record_virtual_memory_reserve((address)result, bytes, CALLER_PC); |
|
c18152e0554e
8013120: NMT: Kitchensink crashes with assert(next_region == NULL || !next_region->is_committed_region()) failed: Sanity check
zgu
parents:
8808
diff
changeset
|
1466 MemTracker::record_virtual_memory_type((address)result, flags); |
|
c18152e0554e
8013120: NMT: Kitchensink crashes with assert(next_region == NULL || !next_region->is_committed_region()) failed: Sanity check
zgu
parents:
8808
diff
changeset
|
1467 } |
|
c18152e0554e
8013120: NMT: Kitchensink crashes with assert(next_region == NULL || !next_region->is_committed_region()) failed: Sanity check
zgu
parents:
8808
diff
changeset
|
1468 |
|
c18152e0554e
8013120: NMT: Kitchensink crashes with assert(next_region == NULL || !next_region->is_committed_region()) failed: Sanity check
zgu
parents:
8808
diff
changeset
|
1469 return result; |
|
c18152e0554e
8013120: NMT: Kitchensink crashes with assert(next_region == NULL || !next_region->is_committed_region()) failed: Sanity check
zgu
parents:
8808
diff
changeset
|
1470 } |
|
c18152e0554e
8013120: NMT: Kitchensink crashes with assert(next_region == NULL || !next_region->is_committed_region()) failed: Sanity check
zgu
parents:
8808
diff
changeset
|
1471 |
| 6197 | 1472 char* os::attempt_reserve_memory_at(size_t bytes, char* addr) { |
| 1473 char* result = pd_attempt_reserve_memory_at(bytes, addr); | |
|
6882
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6816
diff
changeset
|
1474 if (result != NULL) { |
| 6197 | 1475 MemTracker::record_virtual_memory_reserve((address)result, bytes, CALLER_PC); |
| 1476 } | |
| 1477 return result; | |
| 1478 } | |
| 1479 | |
| 1480 void os::split_reserved_memory(char *base, size_t size, | |
| 1481 size_t split, bool realloc) { | |
| 1482 pd_split_reserved_memory(base, size, split, realloc); | |
| 1483 } | |
| 1484 | |
| 1485 bool os::commit_memory(char* addr, size_t bytes, bool executable) { | |
| 1486 bool res = pd_commit_memory(addr, bytes, executable); | |
|
6882
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6816
diff
changeset
|
1487 if (res) { |
| 6197 | 1488 MemTracker::record_virtual_memory_commit((address)addr, bytes, CALLER_PC); |
| 1489 } | |
| 1490 return res; | |
| 1491 } | |
| 1492 | |
| 1493 bool os::commit_memory(char* addr, size_t size, size_t alignment_hint, | |
| 1494 bool executable) { | |
| 1495 bool res = os::pd_commit_memory(addr, size, alignment_hint, executable); | |
|
6882
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6816
diff
changeset
|
1496 if (res) { |
| 6197 | 1497 MemTracker::record_virtual_memory_commit((address)addr, size, CALLER_PC); |
| 1498 } | |
| 1499 return res; | |
| 1500 } | |
| 1501 | |
| 1502 bool os::uncommit_memory(char* addr, size_t bytes) { | |
| 1503 bool res = pd_uncommit_memory(addr, bytes); | |
| 1504 if (res) { | |
| 1505 MemTracker::record_virtual_memory_uncommit((address)addr, bytes); | |
| 1506 } | |
| 1507 return res; | |
| 1508 } | |
| 1509 | |
| 1510 bool os::release_memory(char* addr, size_t bytes) { | |
| 1511 bool res = pd_release_memory(addr, bytes); | |
| 1512 if (res) { | |
| 1513 MemTracker::record_virtual_memory_release((address)addr, bytes); | |
| 1514 } | |
| 1515 return res; | |
| 1516 } | |
| 1517 | |
| 1518 | |
| 1519 char* os::map_memory(int fd, const char* file_name, size_t file_offset, | |
| 1520 char *addr, size_t bytes, bool read_only, | |
| 1521 bool allow_exec) { | |
| 1522 char* result = pd_map_memory(fd, file_name, file_offset, addr, bytes, read_only, allow_exec); | |
|
6882
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6816
diff
changeset
|
1523 if (result != NULL) { |
| 6197 | 1524 MemTracker::record_virtual_memory_reserve((address)result, bytes, CALLER_PC); |
|
6882
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6816
diff
changeset
|
1525 MemTracker::record_virtual_memory_commit((address)result, bytes, CALLER_PC); |
| 6197 | 1526 } |
| 1527 return result; | |
| 1528 } | |
| 1529 | |
| 1530 char* os::remap_memory(int fd, const char* file_name, size_t file_offset, | |
| 1531 char *addr, size_t bytes, bool read_only, | |
| 1532 bool allow_exec) { | |
| 1533 return pd_remap_memory(fd, file_name, file_offset, addr, bytes, | |
| 1534 read_only, allow_exec); | |
| 1535 } | |
| 1536 | |
| 1537 bool os::unmap_memory(char *addr, size_t bytes) { | |
| 1538 bool result = pd_unmap_memory(addr, bytes); | |
| 1539 if (result) { | |
|
6882
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6816
diff
changeset
|
1540 MemTracker::record_virtual_memory_uncommit((address)addr, bytes); |
| 6197 | 1541 MemTracker::record_virtual_memory_release((address)addr, bytes); |
| 1542 } | |
| 1543 return result; | |
| 1544 } | |
| 1545 | |
| 1546 void os::free_memory(char *addr, size_t bytes, size_t alignment_hint) { | |
| 1547 pd_free_memory(addr, bytes, alignment_hint); | |
| 1548 } | |
| 1549 | |
| 1550 void os::realign_memory(char *addr, size_t bytes, size_t alignment_hint) { | |
| 1551 pd_realign_memory(addr, bytes, alignment_hint); | |
| 1552 } | |
| 1553 |