Mercurial > hg > graal-compiler
annotate src/share/vm/runtime/os.cpp @ 12233:40136aa2cdb1
8010722: assert: failed: heap size is too big for compressed oops
Summary: Use conservative assumptions of required alignment for the various garbage collector components into account when determining the maximum heap size that supports compressed oops. Using this conservative value avoids several circular dependencies in the calculation.
Reviewed-by: stefank, dholmes
| author | tschatzl |
|---|---|
| date | Wed, 11 Sep 2013 16:25:02 +0200 |
| parents | c636758ea616 |
| children | 179cd89fb279 |
| 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) { | |
| 10405 | 268 VM_GC_HeapInspection op1(gclog_or_tty, true /* force full GC before heap inspection */); |
| 0 | 269 VMThread::execute(&op1); |
| 270 } | |
| 271 if (JvmtiExport::should_post_data_dump()) { | |
| 272 JvmtiExport::post_data_dump(); | |
| 273 } | |
| 274 break; | |
| 275 } | |
| 276 default: { | |
| 277 // Dispatch the signal to java | |
| 278 HandleMark hm(THREAD); | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
279 Klass* k = SystemDictionary::resolve_or_null(vmSymbols::sun_misc_Signal(), THREAD); |
| 0 | 280 KlassHandle klass (THREAD, k); |
| 281 if (klass.not_null()) { | |
| 282 JavaValue result(T_VOID); | |
| 283 JavaCallArguments args; | |
| 284 args.push_int(sig); | |
| 285 JavaCalls::call_static( | |
| 286 &result, | |
| 287 klass, | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1980
diff
changeset
|
288 vmSymbols::dispatch_name(), |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1980
diff
changeset
|
289 vmSymbols::int_void_signature(), |
| 0 | 290 &args, |
| 291 THREAD | |
| 292 ); | |
| 293 } | |
| 294 if (HAS_PENDING_EXCEPTION) { | |
| 295 // tty is initialized early so we don't expect it to be null, but | |
| 296 // if it is we can't risk doing an initialization that might | |
| 297 // trigger additional out-of-memory conditions | |
| 298 if (tty != NULL) { | |
| 299 char klass_name[256]; | |
| 300 char tmp_sig_name[16]; | |
| 301 const char* sig_name = "UNKNOWN"; | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
302 InstanceKlass::cast(PENDING_EXCEPTION->klass())-> |
| 0 | 303 name()->as_klass_external_name(klass_name, 256); |
| 304 if (os::exception_name(sig, tmp_sig_name, 16) != NULL) | |
| 305 sig_name = tmp_sig_name; | |
| 306 warning("Exception %s occurred dispatching signal %s to handler" | |
| 307 "- the VM may need to be forcibly terminated", | |
| 308 klass_name, sig_name ); | |
| 309 } | |
| 310 CLEAR_PENDING_EXCEPTION; | |
| 311 } | |
| 312 } | |
| 313 } | |
| 314 } | |
| 315 } | |
| 316 | |
|
12233
40136aa2cdb1
8010722: assert: failed: heap size is too big for compressed oops
tschatzl
parents:
12147
diff
changeset
|
317 void os::init_before_ergo() { |
|
40136aa2cdb1
8010722: assert: failed: heap size is too big for compressed oops
tschatzl
parents:
12147
diff
changeset
|
318 // We need to initialize large page support here because ergonomics takes some |
|
40136aa2cdb1
8010722: assert: failed: heap size is too big for compressed oops
tschatzl
parents:
12147
diff
changeset
|
319 // decisions depending on large page support and the calculated large page size. |
|
40136aa2cdb1
8010722: assert: failed: heap size is too big for compressed oops
tschatzl
parents:
12147
diff
changeset
|
320 large_page_init(); |
|
40136aa2cdb1
8010722: assert: failed: heap size is too big for compressed oops
tschatzl
parents:
12147
diff
changeset
|
321 } |
| 0 | 322 |
| 323 void os::signal_init() { | |
| 324 if (!ReduceSignalUsage) { | |
| 325 // Setup JavaThread for processing signals | |
| 326 EXCEPTION_MARK; | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
327 Klass* k = SystemDictionary::resolve_or_fail(vmSymbols::java_lang_Thread(), true, CHECK); |
| 0 | 328 instanceKlassHandle klass (THREAD, k); |
| 329 instanceHandle thread_oop = klass->allocate_instance_handle(CHECK); | |
| 330 | |
| 331 const char thread_name[] = "Signal Dispatcher"; | |
| 332 Handle string = java_lang_String::create_from_str(thread_name, CHECK); | |
| 333 | |
| 334 // Initialize thread_oop to put it into the system threadGroup | |
| 335 Handle thread_group (THREAD, Universe::system_thread_group()); | |
| 336 JavaValue result(T_VOID); | |
| 337 JavaCalls::call_special(&result, thread_oop, | |
| 338 klass, | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1980
diff
changeset
|
339 vmSymbols::object_initializer_name(), |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1980
diff
changeset
|
340 vmSymbols::threadgroup_string_void_signature(), |
| 0 | 341 thread_group, |
| 342 string, | |
| 343 CHECK); | |
| 344 | |
| 1142 | 345 KlassHandle group(THREAD, SystemDictionary::ThreadGroup_klass()); |
| 0 | 346 JavaCalls::call_special(&result, |
| 347 thread_group, | |
| 348 group, | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1980
diff
changeset
|
349 vmSymbols::add_method_name(), |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1980
diff
changeset
|
350 vmSymbols::thread_void_signature(), |
| 0 | 351 thread_oop, // ARG 1 |
| 352 CHECK); | |
| 353 | |
| 354 os::signal_init_pd(); | |
| 355 | |
| 356 { MutexLocker mu(Threads_lock); | |
| 357 JavaThread* signal_thread = new JavaThread(&signal_thread_entry); | |
| 358 | |
| 359 // At this point it may be possible that no osthread was created for the | |
| 360 // JavaThread due to lack of memory. We would have to throw an exception | |
| 361 // in that case. However, since this must work and we do not allow | |
| 362 // exceptions anyway, check and abort if this fails. | |
| 363 if (signal_thread == NULL || signal_thread->osthread() == NULL) { | |
| 364 vm_exit_during_initialization("java.lang.OutOfMemoryError", | |
| 365 "unable to create new native thread"); | |
| 366 } | |
| 367 | |
| 368 java_lang_Thread::set_thread(thread_oop(), signal_thread); | |
| 369 java_lang_Thread::set_priority(thread_oop(), NearMaxPriority); | |
| 370 java_lang_Thread::set_daemon(thread_oop()); | |
| 371 | |
| 372 signal_thread->set_threadObj(thread_oop()); | |
| 373 Threads::add(signal_thread); | |
| 374 Thread::start(signal_thread); | |
| 375 } | |
| 376 // Handle ^BREAK | |
| 377 os::signal(SIGBREAK, os::user_handler()); | |
| 378 } | |
| 379 } | |
| 380 | |
| 381 | |
| 382 void os::terminate_signal_thread() { | |
| 383 if (!ReduceSignalUsage) | |
| 384 signal_notify(sigexitnum_pd()); | |
| 385 } | |
| 386 | |
| 387 | |
| 388 // --------------------- loading libraries --------------------- | |
| 389 | |
| 390 typedef jint (JNICALL *JNI_OnLoad_t)(JavaVM *, void *); | |
| 391 extern struct JavaVM_ main_vm; | |
| 392 | |
| 393 static void* _native_java_library = NULL; | |
| 394 | |
| 395 void* os::native_java_library() { | |
| 396 if (_native_java_library == NULL) { | |
| 397 char buffer[JVM_MAXPATHLEN]; | |
| 398 char ebuf[1024]; | |
| 399 | |
| 242 | 400 // Try to load verify dll first. In 1.3 java dll depends on it and is not |
| 401 // always able to find it when the loading executable is outside the JDK. | |
| 0 | 402 // 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
|
403 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
|
404 "verify")) { |
|
6cb0d32b828b
8001185: parsing of sun.boot.library.path in os::dll_build_name somewhat broken
bpittore
parents:
6882
diff
changeset
|
405 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
|
406 } |
| 0 | 407 |
| 408 // Load java dll | |
|
6966
6cb0d32b828b
8001185: parsing of sun.boot.library.path in os::dll_build_name somewhat broken
bpittore
parents:
6882
diff
changeset
|
409 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
|
410 "java")) { |
|
6cb0d32b828b
8001185: parsing of sun.boot.library.path in os::dll_build_name somewhat broken
bpittore
parents:
6882
diff
changeset
|
411 _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
|
412 } |
| 0 | 413 if (_native_java_library == NULL) { |
| 414 vm_exit_during_initialization("Unable to load native library", ebuf); | |
| 415 } | |
| 3960 | 416 |
| 417 #if defined(__OpenBSD__) | |
| 418 // Work-around OpenBSD's lack of $ORIGIN support by pre-loading libnet.so | |
| 419 // ignore errors | |
|
6966
6cb0d32b828b
8001185: parsing of sun.boot.library.path in os::dll_build_name somewhat broken
bpittore
parents:
6882
diff
changeset
|
420 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
|
421 "net")) { |
|
6cb0d32b828b
8001185: parsing of sun.boot.library.path in os::dll_build_name somewhat broken
bpittore
parents:
6882
diff
changeset
|
422 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
|
423 } |
| 3960 | 424 #endif |
| 242 | 425 } |
| 426 static jboolean onLoaded = JNI_FALSE; | |
| 427 if (onLoaded) { | |
| 428 // We may have to wait to fire OnLoad until TLS is initialized. | |
| 429 if (ThreadLocalStorage::is_initialized()) { | |
| 430 // The JNI_OnLoad handling is normally done by method load in | |
| 431 // java.lang.ClassLoader$NativeLibrary, but the VM loads the base library | |
| 432 // explicitly so we have to check for JNI_OnLoad as well | |
| 433 const char *onLoadSymbols[] = JNI_ONLOAD_SYMBOLS; | |
| 434 JNI_OnLoad_t JNI_OnLoad = CAST_TO_FN_PTR( | |
| 435 JNI_OnLoad_t, dll_lookup(_native_java_library, onLoadSymbols[0])); | |
| 436 if (JNI_OnLoad != NULL) { | |
| 437 JavaThread* thread = JavaThread::current(); | |
| 438 ThreadToNativeFromVM ttn(thread); | |
| 439 HandleMark hm(thread); | |
| 440 jint ver = (*JNI_OnLoad)(&main_vm, NULL); | |
| 441 onLoaded = JNI_TRUE; | |
| 442 if (!Threads::is_supported_jni_version_including_1_1(ver)) { | |
| 443 vm_exit_during_initialization("Unsupported JNI version"); | |
| 444 } | |
| 0 | 445 } |
| 446 } | |
| 447 } | |
| 448 return _native_java_library; | |
| 449 } | |
| 450 | |
|
12117
f92b82d454fa
8014135: The JVMTI specification does not conform to recent changes in JNI specification
bpittore
parents:
11151
diff
changeset
|
451 /* |
|
f92b82d454fa
8014135: The JVMTI specification does not conform to recent changes in JNI specification
bpittore
parents:
11151
diff
changeset
|
452 * Support for finding Agent_On(Un)Load/Attach<_lib_name> if it exists. |
|
f92b82d454fa
8014135: The JVMTI specification does not conform to recent changes in JNI specification
bpittore
parents:
11151
diff
changeset
|
453 * If check_lib == true then we are looking for an |
|
f92b82d454fa
8014135: The JVMTI specification does not conform to recent changes in JNI specification
bpittore
parents:
11151
diff
changeset
|
454 * Agent_OnLoad_lib_name or Agent_OnAttach_lib_name function to determine if |
|
f92b82d454fa
8014135: The JVMTI specification does not conform to recent changes in JNI specification
bpittore
parents:
11151
diff
changeset
|
455 * this library is statically linked into the image. |
|
f92b82d454fa
8014135: The JVMTI specification does not conform to recent changes in JNI specification
bpittore
parents:
11151
diff
changeset
|
456 * If check_lib == false then we will look for the appropriate symbol in the |
|
f92b82d454fa
8014135: The JVMTI specification does not conform to recent changes in JNI specification
bpittore
parents:
11151
diff
changeset
|
457 * executable if agent_lib->is_static_lib() == true or in the shared library |
|
f92b82d454fa
8014135: The JVMTI specification does not conform to recent changes in JNI specification
bpittore
parents:
11151
diff
changeset
|
458 * referenced by 'handle'. |
|
f92b82d454fa
8014135: The JVMTI specification does not conform to recent changes in JNI specification
bpittore
parents:
11151
diff
changeset
|
459 */ |
|
f92b82d454fa
8014135: The JVMTI specification does not conform to recent changes in JNI specification
bpittore
parents:
11151
diff
changeset
|
460 void* os::find_agent_function(AgentLibrary *agent_lib, bool check_lib, |
|
f92b82d454fa
8014135: The JVMTI specification does not conform to recent changes in JNI specification
bpittore
parents:
11151
diff
changeset
|
461 const char *syms[], size_t syms_len) { |
|
f92b82d454fa
8014135: The JVMTI specification does not conform to recent changes in JNI specification
bpittore
parents:
11151
diff
changeset
|
462 const char *lib_name; |
|
f92b82d454fa
8014135: The JVMTI specification does not conform to recent changes in JNI specification
bpittore
parents:
11151
diff
changeset
|
463 void *handle = agent_lib->os_lib(); |
|
f92b82d454fa
8014135: The JVMTI specification does not conform to recent changes in JNI specification
bpittore
parents:
11151
diff
changeset
|
464 void *entryName = NULL; |
|
f92b82d454fa
8014135: The JVMTI specification does not conform to recent changes in JNI specification
bpittore
parents:
11151
diff
changeset
|
465 char *agent_function_name; |
|
f92b82d454fa
8014135: The JVMTI specification does not conform to recent changes in JNI specification
bpittore
parents:
11151
diff
changeset
|
466 size_t i; |
|
f92b82d454fa
8014135: The JVMTI specification does not conform to recent changes in JNI specification
bpittore
parents:
11151
diff
changeset
|
467 |
|
f92b82d454fa
8014135: The JVMTI specification does not conform to recent changes in JNI specification
bpittore
parents:
11151
diff
changeset
|
468 // If checking then use the agent name otherwise test is_static_lib() to |
|
f92b82d454fa
8014135: The JVMTI specification does not conform to recent changes in JNI specification
bpittore
parents:
11151
diff
changeset
|
469 // see how to process this lookup |
|
f92b82d454fa
8014135: The JVMTI specification does not conform to recent changes in JNI specification
bpittore
parents:
11151
diff
changeset
|
470 lib_name = ((check_lib || agent_lib->is_static_lib()) ? agent_lib->name() : NULL); |
|
f92b82d454fa
8014135: The JVMTI specification does not conform to recent changes in JNI specification
bpittore
parents:
11151
diff
changeset
|
471 for (i = 0; i < syms_len; i++) { |
|
f92b82d454fa
8014135: The JVMTI specification does not conform to recent changes in JNI specification
bpittore
parents:
11151
diff
changeset
|
472 agent_function_name = build_agent_function_name(syms[i], lib_name, agent_lib->is_absolute_path()); |
|
f92b82d454fa
8014135: The JVMTI specification does not conform to recent changes in JNI specification
bpittore
parents:
11151
diff
changeset
|
473 if (agent_function_name == NULL) { |
|
f92b82d454fa
8014135: The JVMTI specification does not conform to recent changes in JNI specification
bpittore
parents:
11151
diff
changeset
|
474 break; |
|
f92b82d454fa
8014135: The JVMTI specification does not conform to recent changes in JNI specification
bpittore
parents:
11151
diff
changeset
|
475 } |
|
f92b82d454fa
8014135: The JVMTI specification does not conform to recent changes in JNI specification
bpittore
parents:
11151
diff
changeset
|
476 entryName = dll_lookup(handle, agent_function_name); |
|
f92b82d454fa
8014135: The JVMTI specification does not conform to recent changes in JNI specification
bpittore
parents:
11151
diff
changeset
|
477 FREE_C_HEAP_ARRAY(char, agent_function_name, mtThread); |
|
f92b82d454fa
8014135: The JVMTI specification does not conform to recent changes in JNI specification
bpittore
parents:
11151
diff
changeset
|
478 if (entryName != NULL) { |
|
f92b82d454fa
8014135: The JVMTI specification does not conform to recent changes in JNI specification
bpittore
parents:
11151
diff
changeset
|
479 break; |
|
f92b82d454fa
8014135: The JVMTI specification does not conform to recent changes in JNI specification
bpittore
parents:
11151
diff
changeset
|
480 } |
|
f92b82d454fa
8014135: The JVMTI specification does not conform to recent changes in JNI specification
bpittore
parents:
11151
diff
changeset
|
481 } |
|
f92b82d454fa
8014135: The JVMTI specification does not conform to recent changes in JNI specification
bpittore
parents:
11151
diff
changeset
|
482 return entryName; |
|
f92b82d454fa
8014135: The JVMTI specification does not conform to recent changes in JNI specification
bpittore
parents:
11151
diff
changeset
|
483 } |
|
f92b82d454fa
8014135: The JVMTI specification does not conform to recent changes in JNI specification
bpittore
parents:
11151
diff
changeset
|
484 |
|
f92b82d454fa
8014135: The JVMTI specification does not conform to recent changes in JNI specification
bpittore
parents:
11151
diff
changeset
|
485 // See if the passed in agent is statically linked into the VM image. |
|
f92b82d454fa
8014135: The JVMTI specification does not conform to recent changes in JNI specification
bpittore
parents:
11151
diff
changeset
|
486 bool os::find_builtin_agent(AgentLibrary *agent_lib, const char *syms[], |
|
f92b82d454fa
8014135: The JVMTI specification does not conform to recent changes in JNI specification
bpittore
parents:
11151
diff
changeset
|
487 size_t syms_len) { |
|
f92b82d454fa
8014135: The JVMTI specification does not conform to recent changes in JNI specification
bpittore
parents:
11151
diff
changeset
|
488 void *ret; |
|
f92b82d454fa
8014135: The JVMTI specification does not conform to recent changes in JNI specification
bpittore
parents:
11151
diff
changeset
|
489 void *proc_handle; |
|
f92b82d454fa
8014135: The JVMTI specification does not conform to recent changes in JNI specification
bpittore
parents:
11151
diff
changeset
|
490 void *save_handle; |
|
f92b82d454fa
8014135: The JVMTI specification does not conform to recent changes in JNI specification
bpittore
parents:
11151
diff
changeset
|
491 |
|
f92b82d454fa
8014135: The JVMTI specification does not conform to recent changes in JNI specification
bpittore
parents:
11151
diff
changeset
|
492 if (agent_lib->name() == NULL) { |
|
f92b82d454fa
8014135: The JVMTI specification does not conform to recent changes in JNI specification
bpittore
parents:
11151
diff
changeset
|
493 return false; |
|
f92b82d454fa
8014135: The JVMTI specification does not conform to recent changes in JNI specification
bpittore
parents:
11151
diff
changeset
|
494 } |
|
f92b82d454fa
8014135: The JVMTI specification does not conform to recent changes in JNI specification
bpittore
parents:
11151
diff
changeset
|
495 proc_handle = get_default_process_handle(); |
|
f92b82d454fa
8014135: The JVMTI specification does not conform to recent changes in JNI specification
bpittore
parents:
11151
diff
changeset
|
496 // Check for Agent_OnLoad/Attach_lib_name function |
|
f92b82d454fa
8014135: The JVMTI specification does not conform to recent changes in JNI specification
bpittore
parents:
11151
diff
changeset
|
497 save_handle = agent_lib->os_lib(); |
|
f92b82d454fa
8014135: The JVMTI specification does not conform to recent changes in JNI specification
bpittore
parents:
11151
diff
changeset
|
498 // We want to look in this process' symbol table. |
|
f92b82d454fa
8014135: The JVMTI specification does not conform to recent changes in JNI specification
bpittore
parents:
11151
diff
changeset
|
499 agent_lib->set_os_lib(proc_handle); |
|
f92b82d454fa
8014135: The JVMTI specification does not conform to recent changes in JNI specification
bpittore
parents:
11151
diff
changeset
|
500 ret = find_agent_function(agent_lib, true, syms, syms_len); |
|
f92b82d454fa
8014135: The JVMTI specification does not conform to recent changes in JNI specification
bpittore
parents:
11151
diff
changeset
|
501 agent_lib->set_os_lib(save_handle); |
|
f92b82d454fa
8014135: The JVMTI specification does not conform to recent changes in JNI specification
bpittore
parents:
11151
diff
changeset
|
502 if (ret != NULL) { |
|
f92b82d454fa
8014135: The JVMTI specification does not conform to recent changes in JNI specification
bpittore
parents:
11151
diff
changeset
|
503 // Found an entry point like Agent_OnLoad_lib_name so we have a static agent |
|
f92b82d454fa
8014135: The JVMTI specification does not conform to recent changes in JNI specification
bpittore
parents:
11151
diff
changeset
|
504 agent_lib->set_os_lib(proc_handle); |
|
f92b82d454fa
8014135: The JVMTI specification does not conform to recent changes in JNI specification
bpittore
parents:
11151
diff
changeset
|
505 agent_lib->set_valid(); |
|
f92b82d454fa
8014135: The JVMTI specification does not conform to recent changes in JNI specification
bpittore
parents:
11151
diff
changeset
|
506 agent_lib->set_static_lib(true); |
|
f92b82d454fa
8014135: The JVMTI specification does not conform to recent changes in JNI specification
bpittore
parents:
11151
diff
changeset
|
507 return true; |
|
f92b82d454fa
8014135: The JVMTI specification does not conform to recent changes in JNI specification
bpittore
parents:
11151
diff
changeset
|
508 } |
|
f92b82d454fa
8014135: The JVMTI specification does not conform to recent changes in JNI specification
bpittore
parents:
11151
diff
changeset
|
509 return false; |
|
f92b82d454fa
8014135: The JVMTI specification does not conform to recent changes in JNI specification
bpittore
parents:
11151
diff
changeset
|
510 } |
|
f92b82d454fa
8014135: The JVMTI specification does not conform to recent changes in JNI specification
bpittore
parents:
11151
diff
changeset
|
511 |
| 0 | 512 // --------------------- heap allocation utilities --------------------- |
| 513 | |
| 6197 | 514 char *os::strdup(const char *str, MEMFLAGS flags) { |
| 0 | 515 size_t size = strlen(str); |
| 6197 | 516 char *dup_str = (char *)malloc(size + 1, flags); |
| 0 | 517 if (dup_str == NULL) return NULL; |
| 518 strcpy(dup_str, str); | |
| 519 return dup_str; | |
| 520 } | |
| 521 | |
| 522 | |
| 523 | |
| 524 #ifdef ASSERT | |
| 525 #define space_before (MallocCushion + sizeof(double)) | |
| 526 #define space_after MallocCushion | |
| 527 #define size_addr_from_base(p) (size_t*)(p + space_before - sizeof(size_t)) | |
| 528 #define size_addr_from_obj(p) ((size_t*)p - 1) | |
| 529 // MallocCushion: size of extra cushion allocated around objects with +UseMallocOnly | |
| 530 // NB: cannot be debug variable, because these aren't set from the command line until | |
| 531 // *after* the first few allocs already happened | |
| 532 #define MallocCushion 16 | |
| 533 #else | |
| 534 #define space_before 0 | |
| 535 #define space_after 0 | |
| 536 #define size_addr_from_base(p) should not use w/o ASSERT | |
| 537 #define size_addr_from_obj(p) should not use w/o ASSERT | |
| 538 #define MallocCushion 0 | |
| 539 #endif | |
| 540 #define paranoid 0 /* only set to 1 if you suspect checking code has bug */ | |
| 541 | |
| 542 #ifdef ASSERT | |
| 543 inline size_t get_size(void* obj) { | |
| 544 size_t size = *size_addr_from_obj(obj); | |
|
1490
f03d0a26bf83
6888954: argument formatting for assert() and friends
jcoomes
parents:
1142
diff
changeset
|
545 if (size < 0) { |
|
f03d0a26bf83
6888954: argument formatting for assert() and friends
jcoomes
parents:
1142
diff
changeset
|
546 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
|
547 SIZE_FORMAT ")", obj, size)); |
|
f03d0a26bf83
6888954: argument formatting for assert() and friends
jcoomes
parents:
1142
diff
changeset
|
548 } |
| 0 | 549 return size; |
| 550 } | |
| 551 | |
| 552 u_char* find_cushion_backwards(u_char* start) { | |
| 553 u_char* p = start; | |
| 554 while (p[ 0] != badResourceValue || p[-1] != badResourceValue || | |
| 555 p[-2] != badResourceValue || p[-3] != badResourceValue) p--; | |
| 556 // ok, we have four consecutive marker bytes; find start | |
| 557 u_char* q = p - 4; | |
| 558 while (*q == badResourceValue) q--; | |
| 559 return q + 1; | |
| 560 } | |
| 561 | |
| 562 u_char* find_cushion_forwards(u_char* start) { | |
| 563 u_char* p = start; | |
| 564 while (p[0] != badResourceValue || p[1] != badResourceValue || | |
| 565 p[2] != badResourceValue || p[3] != badResourceValue) p++; | |
| 566 // ok, we have four consecutive marker bytes; find end of cushion | |
| 567 u_char* q = p + 4; | |
| 568 while (*q == badResourceValue) q++; | |
| 569 return q - MallocCushion; | |
| 570 } | |
| 571 | |
| 572 void print_neighbor_blocks(void* ptr) { | |
| 573 // find block allocated before ptr (not entirely crash-proof) | |
| 574 if (MallocCushion < 4) { | |
| 575 tty->print_cr("### cannot find previous block (MallocCushion < 4)"); | |
| 576 return; | |
| 577 } | |
| 578 u_char* start_of_this_block = (u_char*)ptr - space_before; | |
| 579 u_char* end_of_prev_block_data = start_of_this_block - space_after -1; | |
| 580 // look for cushion in front of prev. block | |
| 581 u_char* start_of_prev_block = find_cushion_backwards(end_of_prev_block_data); | |
| 582 ptrdiff_t size = *size_addr_from_base(start_of_prev_block); | |
| 583 u_char* obj = start_of_prev_block + space_before; | |
| 584 if (size <= 0 ) { | |
| 585 // start is bad; mayhave been confused by OS data inbetween objects | |
| 586 // search one more backwards | |
| 587 start_of_prev_block = find_cushion_backwards(start_of_prev_block); | |
| 588 size = *size_addr_from_base(start_of_prev_block); | |
| 589 obj = start_of_prev_block + space_before; | |
| 590 } | |
| 591 | |
| 592 if (start_of_prev_block + space_before + size + space_after == start_of_this_block) { | |
| 2250 | 593 tty->print_cr("### previous object: " PTR_FORMAT " (" SSIZE_FORMAT " bytes)", obj, size); |
| 0 | 594 } else { |
| 2250 | 595 tty->print_cr("### previous object (not sure if correct): " PTR_FORMAT " (" SSIZE_FORMAT " bytes)", obj, size); |
| 0 | 596 } |
| 597 | |
| 598 // now find successor block | |
| 599 u_char* start_of_next_block = (u_char*)ptr + *size_addr_from_obj(ptr) + space_after; | |
| 600 start_of_next_block = find_cushion_forwards(start_of_next_block); | |
| 601 u_char* next_obj = start_of_next_block + space_before; | |
| 602 ptrdiff_t next_size = *size_addr_from_base(start_of_next_block); | |
| 603 if (start_of_next_block[0] == badResourceValue && | |
| 604 start_of_next_block[1] == badResourceValue && | |
| 605 start_of_next_block[2] == badResourceValue && | |
| 606 start_of_next_block[3] == badResourceValue) { | |
| 2250 | 607 tty->print_cr("### next object: " PTR_FORMAT " (" SSIZE_FORMAT " bytes)", next_obj, next_size); |
| 0 | 608 } else { |
| 2250 | 609 tty->print_cr("### next object (not sure if correct): " PTR_FORMAT " (" SSIZE_FORMAT " bytes)", next_obj, next_size); |
| 0 | 610 } |
| 611 } | |
| 612 | |
| 613 | |
| 614 void report_heap_error(void* memblock, void* bad, const char* where) { | |
| 2250 | 615 tty->print_cr("## nof_mallocs = " UINT64_FORMAT ", nof_frees = " UINT64_FORMAT, os::num_mallocs, os::num_frees); |
| 616 tty->print_cr("## memory stomp: byte at " PTR_FORMAT " %s object " PTR_FORMAT, bad, where, memblock); | |
| 0 | 617 print_neighbor_blocks(memblock); |
| 618 fatal("memory stomping error"); | |
| 619 } | |
| 620 | |
| 621 void verify_block(void* memblock) { | |
| 622 size_t size = get_size(memblock); | |
| 623 if (MallocCushion) { | |
| 624 u_char* ptr = (u_char*)memblock - space_before; | |
| 625 for (int i = 0; i < MallocCushion; i++) { | |
| 626 if (ptr[i] != badResourceValue) { | |
| 627 report_heap_error(memblock, ptr+i, "in front of"); | |
| 628 } | |
| 629 } | |
| 630 u_char* end = (u_char*)memblock + size + space_after; | |
| 631 for (int j = -MallocCushion; j < 0; j++) { | |
| 632 if (end[j] != badResourceValue) { | |
| 633 report_heap_error(memblock, end+j, "after"); | |
| 634 } | |
| 635 } | |
| 636 } | |
| 637 } | |
| 638 #endif | |
| 639 | |
|
8802
eca90b8a06eb
7030610: runtime/6878713/Test6878713.sh fails Error. failed to clean up files after test
rdurbin
parents:
7994
diff
changeset
|
640 // |
|
eca90b8a06eb
7030610: runtime/6878713/Test6878713.sh fails Error. failed to clean up files after test
rdurbin
parents:
7994
diff
changeset
|
641 // 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
|
642 // 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
|
643 // |
|
eca90b8a06eb
7030610: runtime/6878713/Test6878713.sh fails Error. failed to clean up files after test
rdurbin
parents:
7994
diff
changeset
|
644 static u_char* testMalloc(size_t alloc_size) { |
|
8808
81d1b58c078f
8010396: checking MallocMaxTestWords in testMalloc() function is redundant
rdurbin
parents:
8802
diff
changeset
|
645 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
|
646 |
|
8808
81d1b58c078f
8010396: checking MallocMaxTestWords in testMalloc() function is redundant
rdurbin
parents:
8802
diff
changeset
|
647 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
|
648 return NULL; |
|
eca90b8a06eb
7030610: runtime/6878713/Test6878713.sh fails Error. failed to clean up files after test
rdurbin
parents:
7994
diff
changeset
|
649 } |
|
eca90b8a06eb
7030610: runtime/6878713/Test6878713.sh fails Error. failed to clean up files after test
rdurbin
parents:
7994
diff
changeset
|
650 |
|
eca90b8a06eb
7030610: runtime/6878713/Test6878713.sh fails Error. failed to clean up files after test
rdurbin
parents:
7994
diff
changeset
|
651 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
|
652 |
|
8808
81d1b58c078f
8010396: checking MallocMaxTestWords in testMalloc() function is redundant
rdurbin
parents:
8802
diff
changeset
|
653 if (ptr != NULL) { |
|
8802
eca90b8a06eb
7030610: runtime/6878713/Test6878713.sh fails Error. failed to clean up files after test
rdurbin
parents:
7994
diff
changeset
|
654 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
|
655 (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
|
656 } |
|
eca90b8a06eb
7030610: runtime/6878713/Test6878713.sh fails Error. failed to clean up files after test
rdurbin
parents:
7994
diff
changeset
|
657 return ptr; |
|
eca90b8a06eb
7030610: runtime/6878713/Test6878713.sh fails Error. failed to clean up files after test
rdurbin
parents:
7994
diff
changeset
|
658 } |
|
eca90b8a06eb
7030610: runtime/6878713/Test6878713.sh fails Error. failed to clean up files after test
rdurbin
parents:
7994
diff
changeset
|
659 |
| 6197 | 660 void* os::malloc(size_t size, MEMFLAGS memflags, address caller) { |
| 2250 | 661 NOT_PRODUCT(inc_stat_counter(&num_mallocs, 1)); |
| 662 NOT_PRODUCT(inc_stat_counter(&alloc_bytes, size)); | |
| 0 | 663 |
| 11151 | 664 #ifdef ASSERT |
| 665 // checking for the WatcherThread and crash_protection first | |
| 666 // since os::malloc can be called when the libjvm.{dll,so} is | |
| 667 // first loaded and we don't have a thread yet. | |
| 668 // try to find the thread after we see that the watcher thread | |
| 669 // exists and has crash protection. | |
| 670 WatcherThread *wt = WatcherThread::watcher_thread(); | |
| 671 if (wt != NULL && wt->has_crash_protection()) { | |
| 672 Thread* thread = ThreadLocalStorage::get_thread_slow(); | |
| 673 if (thread == wt) { | |
| 674 assert(!wt->has_crash_protection(), | |
| 675 "Can't malloc with crash protection from WatcherThread"); | |
| 676 } | |
| 677 } | |
| 678 #endif | |
| 679 | |
| 0 | 680 if (size == 0) { |
| 681 // return a valid pointer if size is zero | |
| 682 // if NULL is returned the calling functions assume out of memory. | |
| 683 size = 1; | |
| 684 } | |
|
8802
eca90b8a06eb
7030610: runtime/6878713/Test6878713.sh fails Error. failed to clean up files after test
rdurbin
parents:
7994
diff
changeset
|
685 |
|
eca90b8a06eb
7030610: runtime/6878713/Test6878713.sh fails Error. failed to clean up files after test
rdurbin
parents:
7994
diff
changeset
|
686 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
|
687 |
|
eca90b8a06eb
7030610: runtime/6878713/Test6878713.sh fails Error. failed to clean up files after test
rdurbin
parents:
7994
diff
changeset
|
688 if (size > alloc_size) { // Check for rollover. |
|
6982
e4f764ddb06a
7122219: Passed StringTableSize value not verified
hseigel
parents:
6882
diff
changeset
|
689 return NULL; |
|
e4f764ddb06a
7122219: Passed StringTableSize value not verified
hseigel
parents:
6882
diff
changeset
|
690 } |
|
8802
eca90b8a06eb
7030610: runtime/6878713/Test6878713.sh fails Error. failed to clean up files after test
rdurbin
parents:
7994
diff
changeset
|
691 |
| 0 | 692 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
|
693 |
|
eca90b8a06eb
7030610: runtime/6878713/Test6878713.sh fails Error. failed to clean up files after test
rdurbin
parents:
7994
diff
changeset
|
694 u_char* ptr; |
|
eca90b8a06eb
7030610: runtime/6878713/Test6878713.sh fails Error. failed to clean up files after test
rdurbin
parents:
7994
diff
changeset
|
695 |
|
eca90b8a06eb
7030610: runtime/6878713/Test6878713.sh fails Error. failed to clean up files after test
rdurbin
parents:
7994
diff
changeset
|
696 if (MallocMaxTestWords > 0) { |
|
eca90b8a06eb
7030610: runtime/6878713/Test6878713.sh fails Error. failed to clean up files after test
rdurbin
parents:
7994
diff
changeset
|
697 ptr = testMalloc(alloc_size); |
|
eca90b8a06eb
7030610: runtime/6878713/Test6878713.sh fails Error. failed to clean up files after test
rdurbin
parents:
7994
diff
changeset
|
698 } else { |
|
eca90b8a06eb
7030610: runtime/6878713/Test6878713.sh fails Error. failed to clean up files after test
rdurbin
parents:
7994
diff
changeset
|
699 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
|
700 } |
| 6197 | 701 |
| 0 | 702 #ifdef ASSERT |
| 703 if (ptr == NULL) return NULL; | |
| 704 if (MallocCushion) { | |
| 705 for (u_char* p = ptr; p < ptr + MallocCushion; p++) *p = (u_char)badResourceValue; | |
| 706 u_char* end = ptr + space_before + size; | |
| 707 for (u_char* pq = ptr+MallocCushion; pq < end; pq++) *pq = (u_char)uninitBlockPad; | |
| 708 for (u_char* q = end; q < end + MallocCushion; q++) *q = (u_char)badResourceValue; | |
| 709 } | |
| 710 // put size just before data | |
| 711 *size_addr_from_base(ptr) = size; | |
| 712 #endif | |
| 713 u_char* memblock = ptr + space_before; | |
| 714 if ((intptr_t)memblock == (intptr_t)MallocCatchPtr) { | |
| 2250 | 715 tty->print_cr("os::malloc caught, " SIZE_FORMAT " bytes --> " PTR_FORMAT, size, memblock); |
| 0 | 716 breakpoint(); |
| 717 } | |
| 718 debug_only(if (paranoid) verify_block(memblock)); | |
| 2250 | 719 if (PrintMalloc && tty != NULL) tty->print_cr("os::malloc " SIZE_FORMAT " bytes --> " PTR_FORMAT, size, memblock); |
| 6197 | 720 |
| 721 // we do not track MallocCushion memory | |
| 722 MemTracker::record_malloc((address)memblock, size, memflags, caller == 0 ? CALLER_PC : caller); | |
| 723 | |
| 0 | 724 return memblock; |
| 725 } | |
| 726 | |
| 727 | |
| 6197 | 728 void* os::realloc(void *memblock, size_t size, MEMFLAGS memflags, address caller) { |
| 0 | 729 #ifndef ASSERT |
| 2250 | 730 NOT_PRODUCT(inc_stat_counter(&num_mallocs, 1)); |
| 731 NOT_PRODUCT(inc_stat_counter(&alloc_bytes, size)); | |
|
10986
1f4355cee9a2
8013651: NMT: reserve/release sequence id's in incorrect order due to race
zgu
parents:
10969
diff
changeset
|
732 MemTracker::Tracker tkr = MemTracker::get_realloc_tracker(); |
| 6197 | 733 void* ptr = ::realloc(memblock, size); |
|
6882
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6816
diff
changeset
|
734 if (ptr != NULL) { |
|
10986
1f4355cee9a2
8013651: NMT: reserve/release sequence id's in incorrect order due to race
zgu
parents:
10969
diff
changeset
|
735 tkr.record((address)memblock, (address)ptr, size, memflags, |
| 6197 | 736 caller == 0 ? CALLER_PC : caller); |
|
10986
1f4355cee9a2
8013651: NMT: reserve/release sequence id's in incorrect order due to race
zgu
parents:
10969
diff
changeset
|
737 } else { |
|
1f4355cee9a2
8013651: NMT: reserve/release sequence id's in incorrect order due to race
zgu
parents:
10969
diff
changeset
|
738 tkr.discard(); |
| 6197 | 739 } |
| 740 return ptr; | |
| 0 | 741 #else |
| 742 if (memblock == NULL) { | |
| 6197 | 743 return malloc(size, memflags, (caller == 0 ? CALLER_PC : caller)); |
| 0 | 744 } |
| 745 if ((intptr_t)memblock == (intptr_t)MallocCatchPtr) { | |
| 2250 | 746 tty->print_cr("os::realloc caught " PTR_FORMAT, memblock); |
| 0 | 747 breakpoint(); |
| 748 } | |
| 749 verify_block(memblock); | |
| 750 NOT_PRODUCT(if (MallocVerifyInterval > 0) check_heap()); | |
| 751 if (size == 0) return NULL; | |
| 752 // always move the block | |
| 6197 | 753 void* ptr = malloc(size, memflags, caller == 0 ? CALLER_PC : caller); |
| 2250 | 754 if (PrintMalloc) tty->print_cr("os::remalloc " SIZE_FORMAT " bytes, " PTR_FORMAT " --> " PTR_FORMAT, size, memblock, ptr); |
| 0 | 755 // Copy to new memory if malloc didn't fail |
| 756 if ( ptr != NULL ) { | |
| 757 memcpy(ptr, memblock, MIN2(size, get_size(memblock))); | |
| 758 if (paranoid) verify_block(ptr); | |
| 759 if ((intptr_t)ptr == (intptr_t)MallocCatchPtr) { | |
| 2250 | 760 tty->print_cr("os::realloc caught, " SIZE_FORMAT " bytes --> " PTR_FORMAT, size, ptr); |
| 0 | 761 breakpoint(); |
| 762 } | |
| 763 free(memblock); | |
| 764 } | |
| 765 return ptr; | |
| 766 #endif | |
| 767 } | |
| 768 | |
| 769 | |
| 6197 | 770 void os::free(void *memblock, MEMFLAGS memflags) { |
| 2250 | 771 NOT_PRODUCT(inc_stat_counter(&num_frees, 1)); |
| 0 | 772 #ifdef ASSERT |
| 773 if (memblock == NULL) return; | |
| 774 if ((intptr_t)memblock == (intptr_t)MallocCatchPtr) { | |
| 2250 | 775 if (tty != NULL) tty->print_cr("os::free caught " PTR_FORMAT, memblock); |
| 0 | 776 breakpoint(); |
| 777 } | |
| 778 verify_block(memblock); | |
| 779 NOT_PRODUCT(if (MallocVerifyInterval > 0) check_heap()); | |
| 780 // Added by detlefs. | |
| 781 if (MallocCushion) { | |
| 782 u_char* ptr = (u_char*)memblock - space_before; | |
| 783 for (u_char* p = ptr; p < ptr + MallocCushion; p++) { | |
| 784 guarantee(*p == badResourceValue, | |
| 785 "Thing freed should be malloc result."); | |
| 786 *p = (u_char)freeBlockPad; | |
| 787 } | |
| 788 size_t size = get_size(memblock); | |
| 2250 | 789 inc_stat_counter(&free_bytes, size); |
| 0 | 790 u_char* end = ptr + space_before + size; |
| 791 for (u_char* q = end; q < end + MallocCushion; q++) { | |
| 792 guarantee(*q == badResourceValue, | |
| 793 "Thing freed should be malloc result."); | |
| 794 *q = (u_char)freeBlockPad; | |
| 795 } | |
| 2250 | 796 if (PrintMalloc && tty != NULL) |
|
2333
f767174aac14
7021653: Parfait issue in hotspot/src/share/vm/oops/methodDataOops.hpp
coleenp
parents:
2250
diff
changeset
|
797 fprintf(stderr, "os::free " SIZE_FORMAT " bytes --> " PTR_FORMAT "\n", size, (uintptr_t)memblock); |
| 2250 | 798 } else if (PrintMalloc && tty != NULL) { |
| 799 // 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
|
800 fprintf(stderr, "os::free " PTR_FORMAT "\n", (uintptr_t)memblock); |
| 0 | 801 } |
| 802 #endif | |
| 6197 | 803 MemTracker::record_free((address)memblock, memflags); |
| 804 | |
| 0 | 805 ::free((char*)memblock - space_before); |
| 806 } | |
| 807 | |
| 808 void os::init_random(long initval) { | |
| 809 _rand_seed = initval; | |
| 810 } | |
| 811 | |
| 812 | |
| 813 long os::random() { | |
| 814 /* standard, well-known linear congruential random generator with | |
| 815 * next_rand = (16807*seed) mod (2**31-1) | |
| 816 * see | |
| 817 * (1) "Random Number Generators: Good Ones Are Hard to Find", | |
| 818 * S.K. Park and K.W. Miller, Communications of the ACM 31:10 (Oct 1988), | |
| 819 * (2) "Two Fast Implementations of the 'Minimal Standard' Random | |
| 820 * Number Generator", David G. Carta, Comm. ACM 33, 1 (Jan 1990), pp. 87-88. | |
| 821 */ | |
| 822 const long a = 16807; | |
| 823 const unsigned long m = 2147483647; | |
| 824 const long q = m / a; assert(q == 127773, "weird math"); | |
| 825 const long r = m % a; assert(r == 2836, "weird math"); | |
| 826 | |
| 827 // compute az=2^31p+q | |
| 828 unsigned long lo = a * (long)(_rand_seed & 0xFFFF); | |
| 829 unsigned long hi = a * (long)((unsigned long)_rand_seed >> 16); | |
| 830 lo += (hi & 0x7FFF) << 16; | |
| 831 | |
| 832 // if q overflowed, ignore the overflow and increment q | |
| 833 if (lo > m) { | |
| 834 lo &= m; | |
| 835 ++lo; | |
| 836 } | |
| 837 lo += hi >> 15; | |
| 838 | |
| 839 // if (p+q) overflowed, ignore the overflow and increment (p+q) | |
| 840 if (lo > m) { | |
| 841 lo &= m; | |
| 842 ++lo; | |
| 843 } | |
| 844 return (_rand_seed = lo); | |
| 845 } | |
| 846 | |
| 847 // The INITIALIZED state is distinguished from the SUSPENDED state because the | |
| 848 // conditions in which a thread is first started are different from those in which | |
| 849 // a suspension is resumed. These differences make it hard for us to apply the | |
| 850 // tougher checks when starting threads that we want to do when resuming them. | |
| 851 // However, when start_thread is called as a result of Thread.start, on a Java | |
| 852 // thread, the operation is synchronized on the Java Thread object. So there | |
| 853 // cannot be a race to start the thread and hence for the thread to exit while | |
| 854 // we are working on it. Non-Java threads that start Java threads either have | |
| 855 // to do so in a context in which races are impossible, or should do appropriate | |
| 856 // locking. | |
| 857 | |
| 858 void os::start_thread(Thread* thread) { | |
| 859 // guard suspend/resume | |
| 860 MutexLockerEx ml(thread->SR_lock(), Mutex::_no_safepoint_check_flag); | |
| 861 OSThread* osthread = thread->osthread(); | |
| 862 osthread->set_state(RUNNABLE); | |
| 863 pd_start_thread(thread); | |
| 864 } | |
| 865 | |
| 866 //--------------------------------------------------------------------------- | |
| 867 // Helper functions for fatal error handler | |
| 868 | |
| 869 void os::print_hex_dump(outputStream* st, address start, address end, int unitsize) { | |
| 870 assert(unitsize == 1 || unitsize == 2 || unitsize == 4 || unitsize == 8, "just checking"); | |
| 871 | |
| 872 int cols = 0; | |
| 873 int cols_per_line = 0; | |
| 874 switch (unitsize) { | |
| 875 case 1: cols_per_line = 16; break; | |
| 876 case 2: cols_per_line = 8; break; | |
| 877 case 4: cols_per_line = 4; break; | |
| 878 case 8: cols_per_line = 2; break; | |
| 879 default: return; | |
| 880 } | |
| 881 | |
| 882 address p = start; | |
| 883 st->print(PTR_FORMAT ": ", start); | |
| 884 while (p < end) { | |
| 885 switch (unitsize) { | |
| 886 case 1: st->print("%02x", *(u1*)p); break; | |
| 887 case 2: st->print("%04x", *(u2*)p); break; | |
| 888 case 4: st->print("%08x", *(u4*)p); break; | |
| 889 case 8: st->print("%016" FORMAT64_MODIFIER "x", *(u8*)p); break; | |
| 890 } | |
| 891 p += unitsize; | |
| 892 cols++; | |
| 893 if (cols >= cols_per_line && p < end) { | |
| 894 cols = 0; | |
| 895 st->cr(); | |
| 896 st->print(PTR_FORMAT ": ", p); | |
| 897 } else { | |
| 898 st->print(" "); | |
| 899 } | |
| 900 } | |
| 901 st->cr(); | |
| 902 } | |
| 903 | |
| 904 void os::print_environment_variables(outputStream* st, const char** env_list, | |
| 905 char* buffer, int len) { | |
| 906 if (env_list) { | |
| 907 st->print_cr("Environment Variables:"); | |
| 908 | |
| 909 for (int i = 0; env_list[i] != NULL; i++) { | |
| 910 if (getenv(env_list[i], buffer, len)) { | |
| 911 st->print(env_list[i]); | |
| 912 st->print("="); | |
| 913 st->print_cr(buffer); | |
| 914 } | |
| 915 } | |
| 916 } | |
| 917 } | |
| 918 | |
| 919 void os::print_cpu_info(outputStream* st) { | |
| 920 // cpu | |
| 921 st->print("CPU:"); | |
| 922 st->print("total %d", os::processor_count()); | |
| 923 // It's not safe to query number of active processors after crash | |
| 924 // st->print("(active %d)", os::active_processor_count()); | |
| 925 st->print(" %s", VM_Version::cpu_features()); | |
| 926 st->cr(); | |
|
3800
bf6481e5f96d
7061225: os::print_cpu_info() should support os-specific data
jcoomes
parents:
2469
diff
changeset
|
927 pd_print_cpu_info(st); |
| 0 | 928 } |
| 929 | |
| 930 void os::print_date_and_time(outputStream *st) { | |
| 931 time_t tloc; | |
| 932 (void)time(&tloc); | |
| 933 st->print("time: %s", ctime(&tloc)); // ctime adds newline. | |
| 934 | |
| 935 double t = os::elapsedTime(); | |
| 936 // NOTE: It tends to crash after a SEGV if we want to printf("%f",...) in | |
| 937 // Linux. Must be a bug in glibc ? Workaround is to round "t" to int | |
| 938 // before printf. We lost some precision, but who cares? | |
| 939 st->print_cr("elapsed time: %d seconds", (int)t); | |
| 940 } | |
| 941 | |
|
1681
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
942 // moved from debug.cpp (used to be find()) but still called from there |
| 1907 | 943 // The verbose parameter is only set by the debug code in one case |
| 944 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
|
945 address addr = (address)x; |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
946 CodeBlob* b = CodeCache::find_blob_unsafe(addr); |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
947 if (b != NULL) { |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
948 if (b->is_buffer_blob()) { |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
949 // the interpreter is generated into a buffer blob |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
950 InterpreterCodelet* i = Interpreter::codelet_containing(addr); |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
951 if (i != NULL) { |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6197
diff
changeset
|
952 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
|
953 i->print_on(st); |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
954 return; |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
955 } |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
956 if (Interpreter::contains(addr)) { |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
957 st->print_cr(INTPTR_FORMAT " is pointing into interpreter code" |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
958 " (not bytecode specific)", 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 // |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
962 if (AdapterHandlerLibrary::contains(b)) { |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6197
diff
changeset
|
963 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
|
964 AdapterHandlerLibrary::print_handler_on(st, b); |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
965 } |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
966 // the stubroutines are generated into a buffer blob |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
967 StubCodeDesc* d = StubCodeDesc::desc_for(addr); |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
968 if (d != NULL) { |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6197
diff
changeset
|
969 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
|
970 d->print_on(st); |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6197
diff
changeset
|
971 st->cr(); |
|
1681
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
972 return; |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
973 } |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
974 if (StubRoutines::contains(addr)) { |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
975 st->print_cr(INTPTR_FORMAT " is pointing to an (unnamed) " |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
976 "stub routine", addr); |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
977 return; |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
978 } |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
979 // the InlineCacheBuffer is using stubs generated into a buffer blob |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
980 if (InlineCacheBuffer::contains(addr)) { |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
981 st->print_cr(INTPTR_FORMAT " is pointing into InlineCacheBuffer", addr); |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
982 return; |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
983 } |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
984 VtableStub* v = VtableStubs::stub_containing(addr); |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
985 if (v != NULL) { |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6197
diff
changeset
|
986 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
|
987 v->print_on(st); |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6197
diff
changeset
|
988 st->cr(); |
|
1681
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
989 return; |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
990 } |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
991 } |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6197
diff
changeset
|
992 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
|
993 if (nm != NULL) { |
|
1681
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
994 ResourceMark rm; |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6197
diff
changeset
|
995 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
|
996 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
|
997 if (verbose) { |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6197
diff
changeset
|
998 st->print(" for "); |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6197
diff
changeset
|
999 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
|
1000 } |
|
6816
87ac5c0a404d
8000228: Missing call to cr() when printing entry_point in nmethod, in os::print_location
stefank
parents:
6814
diff
changeset
|
1001 st->cr(); |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6197
diff
changeset
|
1002 nm->print_nmethod(verbose); |
|
1681
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
1003 return; |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
1004 } |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6197
diff
changeset
|
1005 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
|
1006 b->print_on(st); |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
1007 return; |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
1008 } |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
1009 |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
1010 if (Universe::heap()->is_in(addr)) { |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
1011 HeapWord* p = Universe::heap()->block_start(addr); |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
1012 bool print = false; |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
1013 // 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
|
1014 // See if we were just given an oop directly |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
1015 if (p != NULL && Universe::heap()->block_is_obj(p)) { |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
1016 print = true; |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
1017 } else if (p == NULL && ((oopDesc*)addr)->is_oop()) { |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
1018 p = (HeapWord*) addr; |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
1019 print = true; |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
1020 } |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
1021 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
|
1022 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
|
1023 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
|
1024 } else { |
|
85f1cded9793
8000230: Change os::print_location to be more descriptive when a location is pointing into an object
stefank
parents:
6766
diff
changeset
|
1025 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
|
1026 } |
|
1681
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
1027 oop(p)->print_on(st); |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
1028 return; |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
1029 } |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
1030 } else { |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
1031 if (Universe::heap()->is_in_reserved(addr)) { |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
1032 st->print_cr(INTPTR_FORMAT " is an unallocated location " |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
1033 "in the heap", addr); |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
1034 return; |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
1035 } |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
1036 } |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
1037 if (JNIHandles::is_global_handle((jobject) addr)) { |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
1038 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
|
1039 return; |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
1040 } |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
1041 if (JNIHandles::is_weak_global_handle((jobject) addr)) { |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
1042 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
|
1043 return; |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
1044 } |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
1045 #ifndef PRODUCT |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
1046 // we don't keep the block list in product mode |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
1047 if (JNIHandleBlock::any_contains((jobject) addr)) { |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
1048 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
|
1049 return; |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
1050 } |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
1051 #endif |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
1052 |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
1053 for(JavaThread *thread = Threads::first(); thread; thread = thread->next()) { |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
1054 // Check for privilege stack |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
1055 if (thread->privileged_stack_top() != NULL && |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
1056 thread->privileged_stack_top()->contains(addr)) { |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
1057 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
|
1058 "for thread: " INTPTR_FORMAT, addr, thread); |
| 1907 | 1059 if (verbose) thread->print_on(st); |
|
1681
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
1060 return; |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
1061 } |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
1062 // 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
|
1063 if (addr == (address)thread) { |
| 1907 | 1064 if (verbose) { |
| 1065 thread->print_on(st); | |
| 1066 } else { | |
| 1067 st->print_cr(INTPTR_FORMAT " is a thread", addr); | |
| 1068 } | |
|
1681
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
1069 return; |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
1070 } |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
1071 // 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
|
1072 // and print thread info |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
1073 if (thread->stack_base() >= addr && |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
1074 addr > (thread->stack_base() - thread->stack_size())) { |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
1075 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
|
1076 INTPTR_FORMAT, addr, thread); |
| 1907 | 1077 if (verbose) thread->print_on(st); |
|
1681
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
1078 return; |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
1079 } |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
1080 |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
1081 } |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1082 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1083 #ifndef PRODUCT |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1084 // Check if in metaspace. |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1085 if (ClassLoaderDataGraph::contains((address)addr)) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1086 // 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
|
1087 st->print_cr(INTPTR_FORMAT |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1088 " is pointing into metadata", addr); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1089 return; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1090 } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1091 #endif |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1092 |
|
1681
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
1093 // Try an OS specific find |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
1094 if (os::find(addr, st)) { |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
1095 return; |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
1096 } |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1642
diff
changeset
|
1097 |
| 1907 | 1098 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
|
1099 } |
| 0 | 1100 |
| 1101 // Looks like all platforms except IA64 can use the same function to check | |
| 1102 // if C stack is walkable beyond current frame. The check for fp() is not | |
| 1103 // necessary on Sparc, but it's harmless. | |
| 1104 bool os::is_first_C_frame(frame* fr) { | |
| 7994 | 1105 #if defined(IA64) && !defined(_WIN32) |
| 1106 // On IA64 we have to check if the callers bsp is still valid | |
| 1107 // (i.e. within the register stack bounds). | |
| 1108 // Notice: this only works for threads created by the VM and only if | |
| 1109 // we walk the current stack!!! If we want to be able to walk | |
| 1110 // arbitrary other threads, we'll have to somehow store the thread | |
| 1111 // object in the frame. | |
| 1112 Thread *thread = Thread::current(); | |
| 1113 if ((address)fr->fp() <= | |
| 1114 thread->register_stack_base() HPUX_ONLY(+ 0x0) LINUX_ONLY(+ 0x50)) { | |
| 1115 // This check is a little hacky, because on Linux the first C | |
| 1116 // frame's ('start_thread') register stack frame starts at | |
| 1117 // "register_stack_base + 0x48" while on HPUX, the first C frame's | |
| 1118 // ('__pthread_bound_body') register stack frame seems to really | |
| 1119 // start at "register_stack_base". | |
| 1120 return true; | |
| 1121 } else { | |
| 1122 return false; | |
| 1123 } | |
| 1124 #elif defined(IA64) && defined(_WIN32) | |
| 0 | 1125 return true; |
| 7994 | 1126 #else |
| 0 | 1127 // Load up sp, fp, sender sp and sender fp, check for reasonable values. |
| 1128 // Check usp first, because if that's bad the other accessors may fault | |
| 1129 // on some architectures. Ditto ufp second, etc. | |
| 1130 uintptr_t fp_align_mask = (uintptr_t)(sizeof(address)-1); | |
| 1131 // sp on amd can be 32 bit aligned. | |
| 1132 uintptr_t sp_align_mask = (uintptr_t)(sizeof(int)-1); | |
| 1133 | |
| 1134 uintptr_t usp = (uintptr_t)fr->sp(); | |
| 1135 if ((usp & sp_align_mask) != 0) return true; | |
| 1136 | |
| 1137 uintptr_t ufp = (uintptr_t)fr->fp(); | |
| 1138 if ((ufp & fp_align_mask) != 0) return true; | |
| 1139 | |
| 1140 uintptr_t old_sp = (uintptr_t)fr->sender_sp(); | |
| 1141 if ((old_sp & sp_align_mask) != 0) return true; | |
| 1142 if (old_sp == 0 || old_sp == (uintptr_t)-1) return true; | |
| 1143 | |
| 1144 uintptr_t old_fp = (uintptr_t)fr->link(); | |
| 1145 if ((old_fp & fp_align_mask) != 0) return true; | |
| 1146 if (old_fp == 0 || old_fp == (uintptr_t)-1 || old_fp == ufp) return true; | |
| 1147 | |
| 1148 // stack grows downwards; if old_fp is below current fp or if the stack | |
| 1149 // frame is too large, either the stack is corrupted or fp is not saved | |
| 1150 // on stack (i.e. on x86, ebp may be used as general register). The stack | |
| 1151 // is not walkable beyond current frame. | |
| 1152 if (old_fp < ufp) return true; | |
| 1153 if (old_fp - ufp > 64 * K) return true; | |
| 1154 | |
| 1155 return false; | |
| 7994 | 1156 #endif |
| 0 | 1157 } |
| 1158 | |
| 1159 #ifdef ASSERT | |
| 1160 extern "C" void test_random() { | |
| 1161 const double m = 2147483647; | |
| 1162 double mean = 0.0, variance = 0.0, t; | |
| 1163 long reps = 10000; | |
| 1164 unsigned long seed = 1; | |
| 1165 | |
| 1166 tty->print_cr("seed %ld for %ld repeats...", seed, reps); | |
| 1167 os::init_random(seed); | |
| 1168 long num; | |
| 1169 for (int k = 0; k < reps; k++) { | |
| 1170 num = os::random(); | |
| 1171 double u = (double)num / m; | |
| 1172 assert(u >= 0.0 && u <= 1.0, "bad random number!"); | |
| 1173 | |
| 1174 // calculate mean and variance of the random sequence | |
| 1175 mean += u; | |
| 1176 variance += (u*u); | |
| 1177 } | |
| 1178 mean /= reps; | |
| 1179 variance /= (reps - 1); | |
| 1180 | |
| 1181 assert(num == 1043618065, "bad seed"); | |
| 1182 tty->print_cr("mean of the 1st 10000 numbers: %f", mean); | |
| 1183 tty->print_cr("variance of the 1st 10000 numbers: %f", variance); | |
| 1184 const double eps = 0.0001; | |
| 1185 t = fabsd(mean - 0.5018); | |
| 1186 assert(t < eps, "bad mean"); | |
| 1187 t = (variance - 0.3355) < 0.0 ? -(variance - 0.3355) : variance - 0.3355; | |
| 1188 assert(t < eps, "bad variance"); | |
| 1189 } | |
| 1190 #endif | |
| 1191 | |
| 1192 | |
| 1193 // Set up the boot classpath. | |
| 1194 | |
| 1195 char* os::format_boot_path(const char* format_string, | |
| 1196 const char* home, | |
| 1197 int home_len, | |
| 1198 char fileSep, | |
| 1199 char pathSep) { | |
| 1200 assert((fileSep == '/' && pathSep == ':') || | |
| 1201 (fileSep == '\\' && pathSep == ';'), "unexpected seperator chars"); | |
| 1202 | |
| 1203 // Scan the format string to determine the length of the actual | |
| 1204 // boot classpath, and handle platform dependencies as well. | |
| 1205 int formatted_path_len = 0; | |
| 1206 const char* p; | |
| 1207 for (p = format_string; *p != 0; ++p) { | |
| 1208 if (*p == '%') formatted_path_len += home_len - 1; | |
| 1209 ++formatted_path_len; | |
| 1210 } | |
| 1211 | |
| 6197 | 1212 char* formatted_path = NEW_C_HEAP_ARRAY(char, formatted_path_len + 1, mtInternal); |
| 0 | 1213 if (formatted_path == NULL) { |
| 1214 return NULL; | |
| 1215 } | |
| 1216 | |
| 1217 // Create boot classpath from format, substituting separator chars and | |
| 1218 // java home directory. | |
| 1219 char* q = formatted_path; | |
| 1220 for (p = format_string; *p != 0; ++p) { | |
| 1221 switch (*p) { | |
| 1222 case '%': | |
| 1223 strcpy(q, home); | |
| 1224 q += home_len; | |
| 1225 break; | |
| 1226 case '/': | |
| 1227 *q++ = fileSep; | |
| 1228 break; | |
| 1229 case ':': | |
| 1230 *q++ = pathSep; | |
| 1231 break; | |
| 1232 default: | |
| 1233 *q++ = *p; | |
| 1234 } | |
| 1235 } | |
| 1236 *q = '\0'; | |
| 1237 | |
| 1238 assert((q - formatted_path) == formatted_path_len, "formatted_path size botched"); | |
| 1239 return formatted_path; | |
| 1240 } | |
| 1241 | |
| 1242 | |
| 1243 bool os::set_boot_path(char fileSep, char pathSep) { | |
| 1244 const char* home = Arguments::get_java_home(); | |
| 1245 int home_len = (int)strlen(home); | |
| 1246 | |
| 1247 static const char* meta_index_dir_format = "%/lib/"; | |
| 1248 static const char* meta_index_format = "%/lib/meta-index"; | |
| 1249 char* meta_index = format_boot_path(meta_index_format, home, home_len, fileSep, pathSep); | |
| 1250 if (meta_index == NULL) return false; | |
| 1251 char* meta_index_dir = format_boot_path(meta_index_dir_format, home, home_len, fileSep, pathSep); | |
| 1252 if (meta_index_dir == NULL) return false; | |
| 1253 Arguments::set_meta_index_path(meta_index, meta_index_dir); | |
| 1254 | |
| 1255 // Any modification to the JAR-file list, for the boot classpath must be | |
| 1256 // aligned with install/install/make/common/Pack.gmk. Note: boot class | |
| 1257 // path class JARs, are stripped for StackMapTable to reduce download size. | |
| 1258 static const char classpath_format[] = | |
| 1259 "%/lib/resources.jar:" | |
| 1260 "%/lib/rt.jar:" | |
| 1261 "%/lib/sunrsasign.jar:" | |
| 1262 "%/lib/jsse.jar:" | |
| 1263 "%/lib/jce.jar:" | |
| 1264 "%/lib/charsets.jar:" | |
|
4800
94ec88ca68e2
7115199: Add event tracing hooks and Java Flight Recorder infrastructure
phh
parents:
4749
diff
changeset
|
1265 "%/lib/jfr.jar:" |
| 4006 | 1266 #ifdef __APPLE__ |
| 1267 "%/lib/JObjC.jar:" | |
| 1268 #endif | |
| 0 | 1269 "%/classes"; |
| 1270 char* sysclasspath = format_boot_path(classpath_format, home, home_len, fileSep, pathSep); | |
| 1271 if (sysclasspath == NULL) return false; | |
| 1272 Arguments::set_sysclasspath(sysclasspath); | |
| 1273 | |
| 1274 return true; | |
| 1275 } | |
| 1276 | |
| 691 | 1277 /* |
| 1278 * Splits a path, based on its separator, the number of | |
| 1279 * elements is returned back in n. | |
| 1280 * It is the callers responsibility to: | |
| 1281 * a> check the value of n, and n may be 0. | |
| 1282 * b> ignore any empty path elements | |
| 1283 * c> free up the data. | |
| 1284 */ | |
| 1285 char** os::split_path(const char* path, int* n) { | |
| 1286 *n = 0; | |
| 1287 if (path == NULL || strlen(path) == 0) { | |
| 1288 return NULL; | |
| 1289 } | |
| 1290 const char psepchar = *os::path_separator(); | |
| 6197 | 1291 char* inpath = (char*)NEW_C_HEAP_ARRAY(char, strlen(path) + 1, mtInternal); |
| 691 | 1292 if (inpath == NULL) { |
| 1293 return NULL; | |
| 1294 } | |
|
6966
6cb0d32b828b
8001185: parsing of sun.boot.library.path in os::dll_build_name somewhat broken
bpittore
parents:
6882
diff
changeset
|
1295 strcpy(inpath, path); |
| 691 | 1296 int count = 1; |
| 1297 char* p = strchr(inpath, psepchar); | |
| 1298 // Get a count of elements to allocate memory | |
| 1299 while (p != NULL) { | |
| 1300 count++; | |
| 1301 p++; | |
| 1302 p = strchr(p, psepchar); | |
| 1303 } | |
| 6197 | 1304 char** opath = (char**) NEW_C_HEAP_ARRAY(char*, count, mtInternal); |
| 691 | 1305 if (opath == NULL) { |
| 1306 return NULL; | |
| 1307 } | |
| 1308 | |
| 1309 // do the actual splitting | |
| 1310 p = inpath; | |
| 1311 for (int i = 0 ; i < count ; i++) { | |
| 1312 size_t len = strcspn(p, os::path_separator()); | |
| 1313 if (len > JVM_MAXPATHLEN) { | |
| 1314 return NULL; | |
| 1315 } | |
| 1316 // allocate the string and add terminator storage | |
| 6197 | 1317 char* s = (char*)NEW_C_HEAP_ARRAY(char, len + 1, mtInternal); |
| 691 | 1318 if (s == NULL) { |
| 1319 return NULL; | |
| 1320 } | |
| 1321 strncpy(s, p, len); | |
| 1322 s[len] = '\0'; | |
| 1323 opath[i] = s; | |
| 1324 p += len + 1; | |
| 1325 } | |
| 6197 | 1326 FREE_C_HEAP_ARRAY(char, inpath, mtInternal); |
| 691 | 1327 *n = count; |
| 1328 return opath; | |
| 1329 } | |
| 1330 | |
| 0 | 1331 void os::set_memory_serialize_page(address page) { |
| 1332 int count = log2_intptr(sizeof(class JavaThread)) - log2_intptr(64); | |
| 1333 _mem_serialize_page = (volatile int32_t *)page; | |
| 1334 // We initialize the serialization page shift count here | |
| 1335 // We assume a cache line size of 64 bytes | |
| 1336 assert(SerializePageShiftCount == count, | |
| 1337 "thread size changed, fix SerializePageShiftCount constant"); | |
| 1338 set_serialize_page_mask((uintptr_t)(vm_page_size() - sizeof(int32_t))); | |
| 1339 } | |
| 1340 | |
|
55
2a8eb116ebbe
6610420: Debug VM crashes during monitor lock rank checking
xlu
parents:
0
diff
changeset
|
1341 static volatile intptr_t SerializePageLock = 0; |
|
2a8eb116ebbe
6610420: Debug VM crashes during monitor lock rank checking
xlu
parents:
0
diff
changeset
|
1342 |
| 0 | 1343 // This method is called from signal handler when SIGSEGV occurs while the current |
| 1344 // thread tries to store to the "read-only" memory serialize page during state | |
| 1345 // transition. | |
| 1346 void os::block_on_serialize_page_trap() { | |
| 1347 if (TraceSafepoint) { | |
| 1348 tty->print_cr("Block until the serialize page permission restored"); | |
| 1349 } | |
|
55
2a8eb116ebbe
6610420: Debug VM crashes during monitor lock rank checking
xlu
parents:
0
diff
changeset
|
1350 // When VMThread is holding the SerializePageLock during modifying the |
| 0 | 1351 // access permission of the memory serialize page, the following call |
| 1352 // will block until the permission of that page is restored to rw. | |
| 1353 // Generally, it is unsafe to manipulate locks in signal handlers, but in | |
| 1354 // 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
|
1355 // it can occur. |
|
2a8eb116ebbe
6610420: Debug VM crashes during monitor lock rank checking
xlu
parents:
0
diff
changeset
|
1356 Thread::muxAcquire(&SerializePageLock, "set_memory_serialize_page"); |
|
2a8eb116ebbe
6610420: Debug VM crashes during monitor lock rank checking
xlu
parents:
0
diff
changeset
|
1357 Thread::muxRelease(&SerializePageLock); |
| 0 | 1358 } |
| 1359 | |
| 1360 // Serialize all thread state variables | |
| 1361 void os::serialize_thread_states() { | |
| 1362 // On some platforms such as Solaris & Linux, the time duration of the page | |
| 1363 // permission restoration is observed to be much longer than expected due to | |
| 1364 // 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
|
1365 // 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
|
1366 // 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
|
1367 Thread::muxAcquire(&SerializePageLock, "serialize_thread_states"); |
|
237
1fdb98a17101
6716785: implicit null checks not triggering with CompressedOops
coleenp
parents:
196
diff
changeset
|
1368 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
|
1369 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
|
1370 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
|
1371 os::vm_page_size(), MEM_PROT_RW); |
|
55
2a8eb116ebbe
6610420: Debug VM crashes during monitor lock rank checking
xlu
parents:
0
diff
changeset
|
1372 Thread::muxRelease(&SerializePageLock); |
| 0 | 1373 } |
| 1374 | |
| 1375 // Returns true if the current stack pointer is above the stack shadow | |
| 1376 // pages, false otherwise. | |
| 1377 | |
| 1378 bool os::stack_shadow_pages_available(Thread *thread, methodHandle method) { | |
| 1379 assert(StackRedPages > 0 && StackYellowPages > 0,"Sanity check"); | |
| 1380 address sp = current_stack_pointer(); | |
| 1381 // Check if we have StackShadowPages above the yellow zone. This parameter | |
| 605 | 1382 // is dependent on the depth of the maximum VM call stack possible from |
| 0 | 1383 // the handler for stack overflow. 'instanceof' in the stack overflow |
| 1384 // handler or a println uses at least 8k stack of VM and native code | |
| 1385 // respectively. | |
| 1386 const int framesize_in_bytes = | |
| 1387 Interpreter::size_top_interpreter_activation(method()) * wordSize; | |
| 1388 int reserved_area = ((StackShadowPages + StackRedPages + StackYellowPages) | |
| 1389 * vm_page_size()) + framesize_in_bytes; | |
| 1390 // The very lower end of the stack | |
| 1391 address stack_limit = thread->stack_base() - thread->stack_size(); | |
| 1392 return (sp > (stack_limit + reserved_area)); | |
| 1393 } | |
| 1394 | |
| 1395 size_t os::page_size_for_region(size_t region_min_size, size_t region_max_size, | |
| 1396 uint min_pages) | |
| 1397 { | |
| 1398 assert(min_pages > 0, "sanity"); | |
| 1399 if (UseLargePages) { | |
| 1400 const size_t max_page_size = region_max_size / min_pages; | |
| 1401 | |
| 1402 for (unsigned int i = 0; _page_sizes[i] != 0; ++i) { | |
| 1403 const size_t sz = _page_sizes[i]; | |
| 1404 const size_t mask = sz - 1; | |
| 1405 if ((region_min_size & mask) == 0 && (region_max_size & mask) == 0) { | |
| 1406 // The largest page size with no fragmentation. | |
| 1407 return sz; | |
| 1408 } | |
| 1409 | |
| 1410 if (sz <= max_page_size) { | |
| 1411 // The largest page size that satisfies the min_pages requirement. | |
| 1412 return sz; | |
| 1413 } | |
| 1414 } | |
| 1415 } | |
| 1416 | |
| 1417 return vm_page_size(); | |
| 1418 } | |
| 1419 | |
| 1420 #ifndef PRODUCT | |
| 3859 | 1421 void os::trace_page_sizes(const char* str, const size_t* page_sizes, int count) |
| 1422 { | |
| 1423 if (TracePageSizes) { | |
| 1424 tty->print("%s: ", str); | |
| 1425 for (int i = 0; i < count; ++i) { | |
| 1426 tty->print(" " SIZE_FORMAT, page_sizes[i]); | |
| 1427 } | |
| 1428 tty->cr(); | |
| 1429 } | |
| 1430 } | |
| 1431 | |
| 0 | 1432 void os::trace_page_sizes(const char* str, const size_t region_min_size, |
| 1433 const size_t region_max_size, const size_t page_size, | |
| 1434 const char* base, const size_t size) | |
| 1435 { | |
| 1436 if (TracePageSizes) { | |
| 1437 tty->print_cr("%s: min=" SIZE_FORMAT " max=" SIZE_FORMAT | |
| 1438 " pg_sz=" SIZE_FORMAT " base=" PTR_FORMAT | |
| 1439 " size=" SIZE_FORMAT, | |
| 1440 str, region_min_size, region_max_size, | |
| 1441 page_size, base, size); | |
| 1442 } | |
| 1443 } | |
| 1444 #endif // #ifndef PRODUCT | |
| 1445 | |
| 1446 // This is the working definition of a server class machine: | |
| 1447 // >= 2 physical CPU's and >=2GB of memory, with some fuzz | |
| 1448 // because the graphics memory (?) sometimes masks physical memory. | |
| 1449 // If you want to change the definition of a server class machine | |
| 1450 // on some OS or platform, e.g., >=4GB on Windohs platforms, | |
| 1451 // then you'll have to parameterize this method based on that state, | |
| 1452 // as was done for logical processors here, or replicate and | |
| 1453 // specialize this method for each platform. (Or fix os to have | |
| 1454 // some inheritance structure and use subclassing. Sigh.) | |
| 1455 // If you want some platform to always or never behave as a server | |
| 1456 // class machine, change the setting of AlwaysActAsServerClassMachine | |
| 1457 // and NeverActAsServerClassMachine in globals*.hpp. | |
| 1458 bool os::is_server_class_machine() { | |
| 1459 // First check for the early returns | |
| 1460 if (NeverActAsServerClassMachine) { | |
| 1461 return false; | |
| 1462 } | |
| 1463 if (AlwaysActAsServerClassMachine) { | |
| 1464 return true; | |
| 1465 } | |
| 1466 // Then actually look at the machine | |
| 1467 bool result = false; | |
| 1468 const unsigned int server_processors = 2; | |
| 1469 const julong server_memory = 2UL * G; | |
| 1470 // We seem not to get our full complement of memory. | |
| 1471 // We allow some part (1/8?) of the memory to be "missing", | |
| 1472 // based on the sizes of DIMMs, and maybe graphics cards. | |
| 1473 const julong missing_memory = 256UL * M; | |
| 1474 | |
| 1475 /* Is this a server class machine? */ | |
| 1476 if ((os::active_processor_count() >= (int)server_processors) && | |
| 1477 (os::physical_memory() >= (server_memory - missing_memory))) { | |
| 1478 const unsigned int logical_processors = | |
| 1479 VM_Version::logical_processors_per_package(); | |
| 1480 if (logical_processors > 1) { | |
| 1481 const unsigned int physical_packages = | |
| 1482 os::active_processor_count() / logical_processors; | |
| 1483 if (physical_packages > server_processors) { | |
| 1484 result = true; | |
| 1485 } | |
| 1486 } else { | |
| 1487 result = true; | |
| 1488 } | |
| 1489 } | |
| 1490 return result; | |
| 1491 } | |
|
2469
677234770800
7017193: Small memory leak in get_stack_bounds os::create_stack_guard_pages
dsamersoff
parents:
2387
diff
changeset
|
1492 |
| 10405 | 1493 void os::SuspendedThreadTask::run() { |
| 1494 assert(Threads_lock->owned_by_self() || (_thread == VMThread::vm_thread()), "must have threads lock to call this"); | |
| 1495 internal_do_task(); | |
| 1496 _done = true; | |
| 1497 } | |
| 1498 | |
| 6197 | 1499 bool os::create_stack_guard_pages(char* addr, size_t bytes) { |
| 1500 return os::pd_create_stack_guard_pages(addr, bytes); | |
| 1501 } | |
| 1502 | |
| 1503 char* os::reserve_memory(size_t bytes, char* addr, size_t alignment_hint) { | |
| 1504 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
|
1505 if (result != NULL) { |
|
10986
1f4355cee9a2
8013651: NMT: reserve/release sequence id's in incorrect order due to race
zgu
parents:
10969
diff
changeset
|
1506 MemTracker::record_virtual_memory_reserve((address)result, bytes, mtNone, CALLER_PC); |
| 6197 | 1507 } |
| 1508 | |
| 1509 return result; | |
| 1510 } | |
|
10221
c18152e0554e
8013120: NMT: Kitchensink crashes with assert(next_region == NULL || !next_region->is_committed_region()) failed: Sanity check
zgu
parents:
8808
diff
changeset
|
1511 |
|
c18152e0554e
8013120: NMT: Kitchensink crashes with assert(next_region == NULL || !next_region->is_committed_region()) failed: Sanity check
zgu
parents:
8808
diff
changeset
|
1512 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
|
1513 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
|
1514 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
|
1515 if (result != NULL) { |
|
10986
1f4355cee9a2
8013651: NMT: reserve/release sequence id's in incorrect order due to race
zgu
parents:
10969
diff
changeset
|
1516 MemTracker::record_virtual_memory_reserve((address)result, bytes, mtNone, CALLER_PC); |
|
10221
c18152e0554e
8013120: NMT: Kitchensink crashes with assert(next_region == NULL || !next_region->is_committed_region()) failed: Sanity check
zgu
parents:
8808
diff
changeset
|
1517 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
|
1518 } |
|
c18152e0554e
8013120: NMT: Kitchensink crashes with assert(next_region == NULL || !next_region->is_committed_region()) failed: Sanity check
zgu
parents:
8808
diff
changeset
|
1519 |
|
c18152e0554e
8013120: NMT: Kitchensink crashes with assert(next_region == NULL || !next_region->is_committed_region()) failed: Sanity check
zgu
parents:
8808
diff
changeset
|
1520 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
|
1521 } |
|
c18152e0554e
8013120: NMT: Kitchensink crashes with assert(next_region == NULL || !next_region->is_committed_region()) failed: Sanity check
zgu
parents:
8808
diff
changeset
|
1522 |
| 6197 | 1523 char* os::attempt_reserve_memory_at(size_t bytes, char* addr) { |
| 1524 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
|
1525 if (result != NULL) { |
|
10986
1f4355cee9a2
8013651: NMT: reserve/release sequence id's in incorrect order due to race
zgu
parents:
10969
diff
changeset
|
1526 MemTracker::record_virtual_memory_reserve((address)result, bytes, mtNone, CALLER_PC); |
| 6197 | 1527 } |
| 1528 return result; | |
| 1529 } | |
| 1530 | |
| 1531 void os::split_reserved_memory(char *base, size_t size, | |
| 1532 size_t split, bool realloc) { | |
| 1533 pd_split_reserved_memory(base, size, split, realloc); | |
| 1534 } | |
| 1535 | |
| 1536 bool os::commit_memory(char* addr, size_t bytes, bool executable) { | |
| 1537 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
|
1538 if (res) { |
| 6197 | 1539 MemTracker::record_virtual_memory_commit((address)addr, bytes, CALLER_PC); |
| 1540 } | |
| 1541 return res; | |
| 1542 } | |
| 1543 | |
| 1544 bool os::commit_memory(char* addr, size_t size, size_t alignment_hint, | |
| 1545 bool executable) { | |
| 1546 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
|
1547 if (res) { |
| 6197 | 1548 MemTracker::record_virtual_memory_commit((address)addr, size, CALLER_PC); |
| 1549 } | |
| 1550 return res; | |
| 1551 } | |
| 1552 | |
|
10969
a837fa3d3f86
8013057: assert(_needs_gc || SafepointSynchronize::is_at_safepoint()) failed: only read at safepoint
dcubed
parents:
10405
diff
changeset
|
1553 void os::commit_memory_or_exit(char* addr, size_t bytes, bool executable, |
|
a837fa3d3f86
8013057: assert(_needs_gc || SafepointSynchronize::is_at_safepoint()) failed: only read at safepoint
dcubed
parents:
10405
diff
changeset
|
1554 const char* mesg) { |
|
a837fa3d3f86
8013057: assert(_needs_gc || SafepointSynchronize::is_at_safepoint()) failed: only read at safepoint
dcubed
parents:
10405
diff
changeset
|
1555 pd_commit_memory_or_exit(addr, bytes, executable, mesg); |
|
a837fa3d3f86
8013057: assert(_needs_gc || SafepointSynchronize::is_at_safepoint()) failed: only read at safepoint
dcubed
parents:
10405
diff
changeset
|
1556 MemTracker::record_virtual_memory_commit((address)addr, bytes, CALLER_PC); |
|
a837fa3d3f86
8013057: assert(_needs_gc || SafepointSynchronize::is_at_safepoint()) failed: only read at safepoint
dcubed
parents:
10405
diff
changeset
|
1557 } |
|
a837fa3d3f86
8013057: assert(_needs_gc || SafepointSynchronize::is_at_safepoint()) failed: only read at safepoint
dcubed
parents:
10405
diff
changeset
|
1558 |
|
a837fa3d3f86
8013057: assert(_needs_gc || SafepointSynchronize::is_at_safepoint()) failed: only read at safepoint
dcubed
parents:
10405
diff
changeset
|
1559 void os::commit_memory_or_exit(char* addr, size_t size, size_t alignment_hint, |
|
a837fa3d3f86
8013057: assert(_needs_gc || SafepointSynchronize::is_at_safepoint()) failed: only read at safepoint
dcubed
parents:
10405
diff
changeset
|
1560 bool executable, const char* mesg) { |
|
a837fa3d3f86
8013057: assert(_needs_gc || SafepointSynchronize::is_at_safepoint()) failed: only read at safepoint
dcubed
parents:
10405
diff
changeset
|
1561 os::pd_commit_memory_or_exit(addr, size, alignment_hint, executable, mesg); |
|
a837fa3d3f86
8013057: assert(_needs_gc || SafepointSynchronize::is_at_safepoint()) failed: only read at safepoint
dcubed
parents:
10405
diff
changeset
|
1562 MemTracker::record_virtual_memory_commit((address)addr, size, CALLER_PC); |
|
a837fa3d3f86
8013057: assert(_needs_gc || SafepointSynchronize::is_at_safepoint()) failed: only read at safepoint
dcubed
parents:
10405
diff
changeset
|
1563 } |
|
a837fa3d3f86
8013057: assert(_needs_gc || SafepointSynchronize::is_at_safepoint()) failed: only read at safepoint
dcubed
parents:
10405
diff
changeset
|
1564 |
| 6197 | 1565 bool os::uncommit_memory(char* addr, size_t bytes) { |
|
10986
1f4355cee9a2
8013651: NMT: reserve/release sequence id's in incorrect order due to race
zgu
parents:
10969
diff
changeset
|
1566 MemTracker::Tracker tkr = MemTracker::get_virtual_memory_uncommit_tracker(); |
| 6197 | 1567 bool res = pd_uncommit_memory(addr, bytes); |
| 1568 if (res) { | |
|
10986
1f4355cee9a2
8013651: NMT: reserve/release sequence id's in incorrect order due to race
zgu
parents:
10969
diff
changeset
|
1569 tkr.record((address)addr, bytes); |
|
1f4355cee9a2
8013651: NMT: reserve/release sequence id's in incorrect order due to race
zgu
parents:
10969
diff
changeset
|
1570 } else { |
|
1f4355cee9a2
8013651: NMT: reserve/release sequence id's in incorrect order due to race
zgu
parents:
10969
diff
changeset
|
1571 tkr.discard(); |
| 6197 | 1572 } |
| 1573 return res; | |
| 1574 } | |
| 1575 | |
| 1576 bool os::release_memory(char* addr, size_t bytes) { | |
|
10986
1f4355cee9a2
8013651: NMT: reserve/release sequence id's in incorrect order due to race
zgu
parents:
10969
diff
changeset
|
1577 MemTracker::Tracker tkr = MemTracker::get_virtual_memory_release_tracker(); |
| 6197 | 1578 bool res = pd_release_memory(addr, bytes); |
| 1579 if (res) { | |
|
10986
1f4355cee9a2
8013651: NMT: reserve/release sequence id's in incorrect order due to race
zgu
parents:
10969
diff
changeset
|
1580 tkr.record((address)addr, bytes); |
|
1f4355cee9a2
8013651: NMT: reserve/release sequence id's in incorrect order due to race
zgu
parents:
10969
diff
changeset
|
1581 } else { |
|
1f4355cee9a2
8013651: NMT: reserve/release sequence id's in incorrect order due to race
zgu
parents:
10969
diff
changeset
|
1582 tkr.discard(); |
| 6197 | 1583 } |
| 1584 return res; | |
| 1585 } | |
| 1586 | |
| 1587 | |
| 1588 char* os::map_memory(int fd, const char* file_name, size_t file_offset, | |
| 1589 char *addr, size_t bytes, bool read_only, | |
| 1590 bool allow_exec) { | |
| 1591 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
|
1592 if (result != NULL) { |
|
10986
1f4355cee9a2
8013651: NMT: reserve/release sequence id's in incorrect order due to race
zgu
parents:
10969
diff
changeset
|
1593 MemTracker::record_virtual_memory_reserve_and_commit((address)result, bytes, mtNone, CALLER_PC); |
| 6197 | 1594 } |
| 1595 return result; | |
| 1596 } | |
| 1597 | |
| 1598 char* os::remap_memory(int fd, const char* file_name, size_t file_offset, | |
| 1599 char *addr, size_t bytes, bool read_only, | |
| 1600 bool allow_exec) { | |
| 1601 return pd_remap_memory(fd, file_name, file_offset, addr, bytes, | |
| 1602 read_only, allow_exec); | |
| 1603 } | |
| 1604 | |
| 1605 bool os::unmap_memory(char *addr, size_t bytes) { | |
|
10986
1f4355cee9a2
8013651: NMT: reserve/release sequence id's in incorrect order due to race
zgu
parents:
10969
diff
changeset
|
1606 MemTracker::Tracker tkr = MemTracker::get_virtual_memory_release_tracker(); |
| 6197 | 1607 bool result = pd_unmap_memory(addr, bytes); |
| 1608 if (result) { | |
|
10986
1f4355cee9a2
8013651: NMT: reserve/release sequence id's in incorrect order due to race
zgu
parents:
10969
diff
changeset
|
1609 tkr.record((address)addr, bytes); |
|
1f4355cee9a2
8013651: NMT: reserve/release sequence id's in incorrect order due to race
zgu
parents:
10969
diff
changeset
|
1610 } else { |
|
1f4355cee9a2
8013651: NMT: reserve/release sequence id's in incorrect order due to race
zgu
parents:
10969
diff
changeset
|
1611 tkr.discard(); |
| 6197 | 1612 } |
| 1613 return result; | |
| 1614 } | |
| 1615 | |
| 1616 void os::free_memory(char *addr, size_t bytes, size_t alignment_hint) { | |
| 1617 pd_free_memory(addr, bytes, alignment_hint); | |
| 1618 } | |
| 1619 | |
| 1620 void os::realign_memory(char *addr, size_t bytes, size_t alignment_hint) { | |
| 1621 pd_realign_memory(addr, bytes, alignment_hint); | |
| 1622 } | |
| 1623 | |
| 10405 | 1624 #ifndef TARGET_OS_FAMILY_windows |
| 1625 /* try to switch state from state "from" to state "to" | |
| 1626 * returns the state set after the method is complete | |
| 1627 */ | |
| 1628 os::SuspendResume::State os::SuspendResume::switch_state(os::SuspendResume::State from, | |
| 1629 os::SuspendResume::State to) | |
| 1630 { | |
| 1631 os::SuspendResume::State result = | |
| 1632 (os::SuspendResume::State) Atomic::cmpxchg((jint) to, (jint *) &_state, (jint) from); | |
| 1633 if (result == from) { | |
| 1634 // success | |
| 1635 return to; | |
| 1636 } | |
| 1637 return result; | |
| 1638 } | |
| 1639 #endif |