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