thread.cpp revision 342:37f87013dfd8
1/*
2 * Copyright 1997-2007 Sun Microsystems, Inc.  All Rights Reserved.
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 *
19 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
20 * CA 95054 USA or visit www.sun.com if you need additional information or
21 * have any questions.
22 *
23 */
24
25# include "incls/_precompiled.incl"
26# include "incls/_thread.cpp.incl"
27
28#ifdef DTRACE_ENABLED
29
30// Only bother with this argument setup if dtrace is available
31
32HS_DTRACE_PROBE_DECL(hotspot, vm__init__begin);
33HS_DTRACE_PROBE_DECL(hotspot, vm__init__end);
34HS_DTRACE_PROBE_DECL5(hotspot, thread__start, char*, intptr_t,
35  intptr_t, intptr_t, bool);
36HS_DTRACE_PROBE_DECL5(hotspot, thread__stop, char*, intptr_t,
37  intptr_t, intptr_t, bool);
38
39#define DTRACE_THREAD_PROBE(probe, javathread)                             \
40  {                                                                        \
41    ResourceMark rm(this);                                                 \
42    int len = 0;                                                           \
43    const char* name = (javathread)->get_thread_name();                    \
44    len = strlen(name);                                                    \
45    HS_DTRACE_PROBE5(hotspot, thread__##probe,                             \
46      name, len,                                                           \
47      java_lang_Thread::thread_id((javathread)->threadObj()),              \
48      (javathread)->osthread()->thread_id(),                               \
49      java_lang_Thread::is_daemon((javathread)->threadObj()));             \
50  }
51
52#else //  ndef DTRACE_ENABLED
53
54#define DTRACE_THREAD_PROBE(probe, javathread)
55
56#endif // ndef DTRACE_ENABLED
57
58// Class hierarchy
59// - Thread
60//   - VMThread
61//   - WatcherThread
62//   - ConcurrentMarkSweepThread
63//   - JavaThread
64//     - CompilerThread
65
66// ======= Thread ========
67
68// Support for forcing alignment of thread objects for biased locking
69void* Thread::operator new(size_t size) {
70  if (UseBiasedLocking) {
71    const int alignment = markOopDesc::biased_lock_alignment;
72    size_t aligned_size = size + (alignment - sizeof(intptr_t));
73    void* real_malloc_addr = CHeapObj::operator new(aligned_size);
74    void* aligned_addr     = (void*) align_size_up((intptr_t) real_malloc_addr, alignment);
75    assert(((uintptr_t) aligned_addr + (uintptr_t) size) <=
76           ((uintptr_t) real_malloc_addr + (uintptr_t) aligned_size),
77           "JavaThread alignment code overflowed allocated storage");
78    if (TraceBiasedLocking) {
79      if (aligned_addr != real_malloc_addr)
80        tty->print_cr("Aligned thread " INTPTR_FORMAT " to " INTPTR_FORMAT,
81                      real_malloc_addr, aligned_addr);
82    }
83    ((Thread*) aligned_addr)->_real_malloc_address = real_malloc_addr;
84    return aligned_addr;
85  } else {
86    return CHeapObj::operator new(size);
87  }
88}
89
90void Thread::operator delete(void* p) {
91  if (UseBiasedLocking) {
92    void* real_malloc_addr = ((Thread*) p)->_real_malloc_address;
93    CHeapObj::operator delete(real_malloc_addr);
94  } else {
95    CHeapObj::operator delete(p);
96  }
97}
98
99
100// Base class for all threads: VMThread, WatcherThread, ConcurrentMarkSweepThread,
101// JavaThread
102
103
104Thread::Thread() {
105  // stack
106  _stack_base   = NULL;
107  _stack_size   = 0;
108  _self_raw_id  = 0;
109  _lgrp_id      = -1;
110  _osthread     = NULL;
111
112  // allocated data structures
113  set_resource_area(new ResourceArea());
114  set_handle_area(new HandleArea(NULL));
115  set_active_handles(NULL);
116  set_free_handle_block(NULL);
117  set_last_handle_mark(NULL);
118  set_osthread(NULL);
119
120  // This initial value ==> never claimed.
121  _oops_do_parity = 0;
122
123  // the handle mark links itself to last_handle_mark
124  new HandleMark(this);
125
126  // plain initialization
127  debug_only(_owned_locks = NULL;)
128  debug_only(_allow_allocation_count = 0;)
129  NOT_PRODUCT(_allow_safepoint_count = 0;)
130  CHECK_UNHANDLED_OOPS_ONLY(_gc_locked_out_count = 0;)
131  _highest_lock = NULL;
132  _jvmti_env_iteration_count = 0;
133  _vm_operation_started_count = 0;
134  _vm_operation_completed_count = 0;
135  _current_pending_monitor = NULL;
136  _current_pending_monitor_is_from_java = true;
137  _current_waiting_monitor = NULL;
138  _num_nested_signal = 0;
139  omFreeList = NULL ;
140  omFreeCount = 0 ;
141  omFreeProvision = 32 ;
142
143  _SR_lock = new Monitor(Mutex::suspend_resume, "SR_lock", true);
144  _suspend_flags = 0;
145
146  // thread-specific hashCode stream generator state - Marsaglia shift-xor form
147  _hashStateX = os::random() ;
148  _hashStateY = 842502087 ;
149  _hashStateZ = 0x8767 ;    // (int)(3579807591LL & 0xffff) ;
150  _hashStateW = 273326509 ;
151
152  _OnTrap   = 0 ;
153  _schedctl = NULL ;
154  _Stalled  = 0 ;
155  _TypeTag  = 0x2BAD ;
156
157  // Many of the following fields are effectively final - immutable
158  // Note that nascent threads can't use the Native Monitor-Mutex
159  // construct until the _MutexEvent is initialized ...
160  // CONSIDER: instead of using a fixed set of purpose-dedicated ParkEvents
161  // we might instead use a stack of ParkEvents that we could provision on-demand.
162  // The stack would act as a cache to avoid calls to ParkEvent::Allocate()
163  // and ::Release()
164  _ParkEvent   = ParkEvent::Allocate (this) ;
165  _SleepEvent  = ParkEvent::Allocate (this) ;
166  _MutexEvent  = ParkEvent::Allocate (this) ;
167  _MuxEvent    = ParkEvent::Allocate (this) ;
168
169#ifdef CHECK_UNHANDLED_OOPS
170  if (CheckUnhandledOops) {
171    _unhandled_oops = new UnhandledOops(this);
172  }
173#endif // CHECK_UNHANDLED_OOPS
174#ifdef ASSERT
175  if (UseBiasedLocking) {
176    assert((((uintptr_t) this) & (markOopDesc::biased_lock_alignment - 1)) == 0, "forced alignment of thread object failed");
177    assert(this == _real_malloc_address ||
178           this == (void*) align_size_up((intptr_t) _real_malloc_address, markOopDesc::biased_lock_alignment),
179           "bug in forced alignment of thread objects");
180  }
181#endif /* ASSERT */
182}
183
184void Thread::initialize_thread_local_storage() {
185  // Note: Make sure this method only calls
186  // non-blocking operations. Otherwise, it might not work
187  // with the thread-startup/safepoint interaction.
188
189  // During Java thread startup, safepoint code should allow this
190  // method to complete because it may need to allocate memory to
191  // store information for the new thread.
192
193  // initialize structure dependent on thread local storage
194  ThreadLocalStorage::set_thread(this);
195
196  // set up any platform-specific state.
197  os::initialize_thread();
198
199}
200
201void Thread::record_stack_base_and_size() {
202  set_stack_base(os::current_stack_base());
203  set_stack_size(os::current_stack_size());
204}
205
206
207Thread::~Thread() {
208  // Reclaim the objectmonitors from the omFreeList of the moribund thread.
209  ObjectSynchronizer::omFlush (this) ;
210
211  // deallocate data structures
212  delete resource_area();
213  // since the handle marks are using the handle area, we have to deallocated the root
214  // handle mark before deallocating the thread's handle area,
215  assert(last_handle_mark() != NULL, "check we have an element");
216  delete last_handle_mark();
217  assert(last_handle_mark() == NULL, "check we have reached the end");
218
219  // It's possible we can encounter a null _ParkEvent, etc., in stillborn threads.
220  // We NULL out the fields for good hygiene.
221  ParkEvent::Release (_ParkEvent)   ; _ParkEvent   = NULL ;
222  ParkEvent::Release (_SleepEvent)  ; _SleepEvent  = NULL ;
223  ParkEvent::Release (_MutexEvent)  ; _MutexEvent  = NULL ;
224  ParkEvent::Release (_MuxEvent)    ; _MuxEvent    = NULL ;
225
226  delete handle_area();
227
228  // osthread() can be NULL, if creation of thread failed.
229  if (osthread() != NULL) os::free_thread(osthread());
230
231  delete _SR_lock;
232
233  // clear thread local storage if the Thread is deleting itself
234  if (this == Thread::current()) {
235    ThreadLocalStorage::set_thread(NULL);
236  } else {
237    // In the case where we're not the current thread, invalidate all the
238    // caches in case some code tries to get the current thread or the
239    // thread that was destroyed, and gets stale information.
240    ThreadLocalStorage::invalidate_all();
241  }
242  CHECK_UNHANDLED_OOPS_ONLY(if (CheckUnhandledOops) delete unhandled_oops();)
243}
244
245// NOTE: dummy function for assertion purpose.
246void Thread::run() {
247  ShouldNotReachHere();
248}
249
250#ifdef ASSERT
251// Private method to check for dangling thread pointer
252void check_for_dangling_thread_pointer(Thread *thread) {
253 assert(!thread->is_Java_thread() || Thread::current() == thread || Threads_lock->owned_by_self(),
254         "possibility of dangling Thread pointer");
255}
256#endif
257
258
259#ifndef PRODUCT
260// Tracing method for basic thread operations
261void Thread::trace(const char* msg, const Thread* const thread) {
262  if (!TraceThreadEvents) return;
263  ResourceMark rm;
264  ThreadCritical tc;
265  const char *name = "non-Java thread";
266  int prio = -1;
267  if (thread->is_Java_thread()
268      && !thread->is_Compiler_thread()) {
269    // The Threads_lock must be held to get information about
270    // this thread but may not be in some situations when
271    // tracing  thread events.
272    bool release_Threads_lock = false;
273    if (!Threads_lock->owned_by_self()) {
274      Threads_lock->lock();
275      release_Threads_lock = true;
276    }
277    JavaThread* jt = (JavaThread *)thread;
278    name = (char *)jt->get_thread_name();
279    oop thread_oop = jt->threadObj();
280    if (thread_oop != NULL) {
281      prio = java_lang_Thread::priority(thread_oop);
282    }
283    if (release_Threads_lock) {
284      Threads_lock->unlock();
285    }
286  }
287  tty->print_cr("Thread::%s " INTPTR_FORMAT " [%lx] %s (prio: %d)", msg, thread, thread->osthread()->thread_id(), name, prio);
288}
289#endif
290
291
292ThreadPriority Thread::get_priority(const Thread* const thread) {
293  trace("get priority", thread);
294  ThreadPriority priority;
295  // Can return an error!
296  (void)os::get_priority(thread, priority);
297  assert(MinPriority <= priority && priority <= MaxPriority, "non-Java priority found");
298  return priority;
299}
300
301void Thread::set_priority(Thread* thread, ThreadPriority priority) {
302  trace("set priority", thread);
303  debug_only(check_for_dangling_thread_pointer(thread);)
304  // Can return an error!
305  (void)os::set_priority(thread, priority);
306}
307
308
309void Thread::start(Thread* thread) {
310  trace("start", thread);
311  // Start is different from resume in that its safety is guaranteed by context or
312  // being called from a Java method synchronized on the Thread object.
313  if (!DisableStartThread) {
314    if (thread->is_Java_thread()) {
315      // Initialize the thread state to RUNNABLE before starting this thread.
316      // Can not set it after the thread started because we do not know the
317      // exact thread state at that time. It could be in MONITOR_WAIT or
318      // in SLEEPING or some other state.
319      java_lang_Thread::set_thread_status(((JavaThread*)thread)->threadObj(),
320                                          java_lang_Thread::RUNNABLE);
321    }
322    os::start_thread(thread);
323  }
324}
325
326// Enqueue a VM_Operation to do the job for us - sometime later
327void Thread::send_async_exception(oop java_thread, oop java_throwable) {
328  VM_ThreadStop* vm_stop = new VM_ThreadStop(java_thread, java_throwable);
329  VMThread::execute(vm_stop);
330}
331
332
333//
334// Check if an external suspend request has completed (or has been
335// cancelled). Returns true if the thread is externally suspended and
336// false otherwise.
337//
338// The bits parameter returns information about the code path through
339// the routine. Useful for debugging:
340//
341// set in is_ext_suspend_completed():
342// 0x00000001 - routine was entered
343// 0x00000010 - routine return false at end
344// 0x00000100 - thread exited (return false)
345// 0x00000200 - suspend request cancelled (return false)
346// 0x00000400 - thread suspended (return true)
347// 0x00001000 - thread is in a suspend equivalent state (return true)
348// 0x00002000 - thread is native and walkable (return true)
349// 0x00004000 - thread is native_trans and walkable (needed retry)
350//
351// set in wait_for_ext_suspend_completion():
352// 0x00010000 - routine was entered
353// 0x00020000 - suspend request cancelled before loop (return false)
354// 0x00040000 - thread suspended before loop (return true)
355// 0x00080000 - suspend request cancelled in loop (return false)
356// 0x00100000 - thread suspended in loop (return true)
357// 0x00200000 - suspend not completed during retry loop (return false)
358//
359
360// Helper class for tracing suspend wait debug bits.
361//
362// 0x00000100 indicates that the target thread exited before it could
363// self-suspend which is not a wait failure. 0x00000200, 0x00020000 and
364// 0x00080000 each indicate a cancelled suspend request so they don't
365// count as wait failures either.
366#define DEBUG_FALSE_BITS (0x00000010 | 0x00200000)
367
368class TraceSuspendDebugBits : public StackObj {
369 private:
370  JavaThread * jt;
371  bool         is_wait;
372  bool         called_by_wait;  // meaningful when !is_wait
373  uint32_t *   bits;
374
375 public:
376  TraceSuspendDebugBits(JavaThread *_jt, bool _is_wait, bool _called_by_wait,
377                        uint32_t *_bits) {
378    jt             = _jt;
379    is_wait        = _is_wait;
380    called_by_wait = _called_by_wait;
381    bits           = _bits;
382  }
383
384  ~TraceSuspendDebugBits() {
385    if (!is_wait) {
386#if 1
387      // By default, don't trace bits for is_ext_suspend_completed() calls.
388      // That trace is very chatty.
389      return;
390#else
391      if (!called_by_wait) {
392        // If tracing for is_ext_suspend_completed() is enabled, then only
393        // trace calls to it from wait_for_ext_suspend_completion()
394        return;
395      }
396#endif
397    }
398
399    if (AssertOnSuspendWaitFailure || TraceSuspendWaitFailures) {
400      if (bits != NULL && (*bits & DEBUG_FALSE_BITS) != 0) {
401        MutexLocker ml(Threads_lock);  // needed for get_thread_name()
402        ResourceMark rm;
403
404        tty->print_cr(
405            "Failed wait_for_ext_suspend_completion(thread=%s, debug_bits=%x)",
406            jt->get_thread_name(), *bits);
407
408        guarantee(!AssertOnSuspendWaitFailure, "external suspend wait failed");
409      }
410    }
411  }
412};
413#undef DEBUG_FALSE_BITS
414
415
416bool JavaThread::is_ext_suspend_completed(bool called_by_wait, int delay, uint32_t *bits) {
417  TraceSuspendDebugBits tsdb(this, false /* !is_wait */, called_by_wait, bits);
418
419  bool did_trans_retry = false;  // only do thread_in_native_trans retry once
420  bool do_trans_retry;           // flag to force the retry
421
422  *bits |= 0x00000001;
423
424  do {
425    do_trans_retry = false;
426
427    if (is_exiting()) {
428      // Thread is in the process of exiting. This is always checked
429      // first to reduce the risk of dereferencing a freed JavaThread.
430      *bits |= 0x00000100;
431      return false;
432    }
433
434    if (!is_external_suspend()) {
435      // Suspend request is cancelled. This is always checked before
436      // is_ext_suspended() to reduce the risk of a rogue resume
437      // confusing the thread that made the suspend request.
438      *bits |= 0x00000200;
439      return false;
440    }
441
442    if (is_ext_suspended()) {
443      // thread is suspended
444      *bits |= 0x00000400;
445      return true;
446    }
447
448    // Now that we no longer do hard suspends of threads running
449    // native code, the target thread can be changing thread state
450    // while we are in this routine:
451    //
452    //   _thread_in_native -> _thread_in_native_trans -> _thread_blocked
453    //
454    // We save a copy of the thread state as observed at this moment
455    // and make our decision about suspend completeness based on the
456    // copy. This closes the race where the thread state is seen as
457    // _thread_in_native_trans in the if-thread_blocked check, but is
458    // seen as _thread_blocked in if-thread_in_native_trans check.
459    JavaThreadState save_state = thread_state();
460
461    if (save_state == _thread_blocked && is_suspend_equivalent()) {
462      // If the thread's state is _thread_blocked and this blocking
463      // condition is known to be equivalent to a suspend, then we can
464      // consider the thread to be externally suspended. This means that
465      // the code that sets _thread_blocked has been modified to do
466      // self-suspension if the blocking condition releases. We also
467      // used to check for CONDVAR_WAIT here, but that is now covered by
468      // the _thread_blocked with self-suspension check.
469      //
470      // Return true since we wouldn't be here unless there was still an
471      // external suspend request.
472      *bits |= 0x00001000;
473      return true;
474    } else if (save_state == _thread_in_native && frame_anchor()->walkable()) {
475      // Threads running native code will self-suspend on native==>VM/Java
476      // transitions. If its stack is walkable (should always be the case
477      // unless this function is called before the actual java_suspend()
478      // call), then the wait is done.
479      *bits |= 0x00002000;
480      return true;
481    } else if (!called_by_wait && !did_trans_retry &&
482               save_state == _thread_in_native_trans &&
483               frame_anchor()->walkable()) {
484      // The thread is transitioning from thread_in_native to another
485      // thread state. check_safepoint_and_suspend_for_native_trans()
486      // will force the thread to self-suspend. If it hasn't gotten
487      // there yet we may have caught the thread in-between the native
488      // code check above and the self-suspend. Lucky us. If we were
489      // called by wait_for_ext_suspend_completion(), then it
490      // will be doing the retries so we don't have to.
491      //
492      // Since we use the saved thread state in the if-statement above,
493      // there is a chance that the thread has already transitioned to
494      // _thread_blocked by the time we get here. In that case, we will
495      // make a single unnecessary pass through the logic below. This
496      // doesn't hurt anything since we still do the trans retry.
497
498      *bits |= 0x00004000;
499
500      // Once the thread leaves thread_in_native_trans for another
501      // thread state, we break out of this retry loop. We shouldn't
502      // need this flag to prevent us from getting back here, but
503      // sometimes paranoia is good.
504      did_trans_retry = true;
505
506      // We wait for the thread to transition to a more usable state.
507      for (int i = 1; i <= SuspendRetryCount; i++) {
508        // We used to do an "os::yield_all(i)" call here with the intention
509        // that yielding would increase on each retry. However, the parameter
510        // is ignored on Linux which means the yield didn't scale up. Waiting
511        // on the SR_lock below provides a much more predictable scale up for
512        // the delay. It also provides a simple/direct point to check for any
513        // safepoint requests from the VMThread
514
515        // temporarily drops SR_lock while doing wait with safepoint check
516        // (if we're a JavaThread - the WatcherThread can also call this)
517        // and increase delay with each retry
518        SR_lock()->wait(!Thread::current()->is_Java_thread(), i * delay);
519
520        // check the actual thread state instead of what we saved above
521        if (thread_state() != _thread_in_native_trans) {
522          // the thread has transitioned to another thread state so
523          // try all the checks (except this one) one more time.
524          do_trans_retry = true;
525          break;
526        }
527      } // end retry loop
528
529
530    }
531  } while (do_trans_retry);
532
533  *bits |= 0x00000010;
534  return false;
535}
536
537//
538// Wait for an external suspend request to complete (or be cancelled).
539// Returns true if the thread is externally suspended and false otherwise.
540//
541bool JavaThread::wait_for_ext_suspend_completion(int retries, int delay,
542       uint32_t *bits) {
543  TraceSuspendDebugBits tsdb(this, true /* is_wait */,
544                             false /* !called_by_wait */, bits);
545
546  // local flag copies to minimize SR_lock hold time
547  bool is_suspended;
548  bool pending;
549  uint32_t reset_bits;
550
551  // set a marker so is_ext_suspend_completed() knows we are the caller
552  *bits |= 0x00010000;
553
554  // We use reset_bits to reinitialize the bits value at the top of
555  // each retry loop. This allows the caller to make use of any
556  // unused bits for their own marking purposes.
557  reset_bits = *bits;
558
559  {
560    MutexLockerEx ml(SR_lock(), Mutex::_no_safepoint_check_flag);
561    is_suspended = is_ext_suspend_completed(true /* called_by_wait */,
562                                            delay, bits);
563    pending = is_external_suspend();
564  }
565  // must release SR_lock to allow suspension to complete
566
567  if (!pending) {
568    // A cancelled suspend request is the only false return from
569    // is_ext_suspend_completed() that keeps us from entering the
570    // retry loop.
571    *bits |= 0x00020000;
572    return false;
573  }
574
575  if (is_suspended) {
576    *bits |= 0x00040000;
577    return true;
578  }
579
580  for (int i = 1; i <= retries; i++) {
581    *bits = reset_bits;  // reinit to only track last retry
582
583    // We used to do an "os::yield_all(i)" call here with the intention
584    // that yielding would increase on each retry. However, the parameter
585    // is ignored on Linux which means the yield didn't scale up. Waiting
586    // on the SR_lock below provides a much more predictable scale up for
587    // the delay. It also provides a simple/direct point to check for any
588    // safepoint requests from the VMThread
589
590    {
591      MutexLocker ml(SR_lock());
592      // wait with safepoint check (if we're a JavaThread - the WatcherThread
593      // can also call this)  and increase delay with each retry
594      SR_lock()->wait(!Thread::current()->is_Java_thread(), i * delay);
595
596      is_suspended = is_ext_suspend_completed(true /* called_by_wait */,
597                                              delay, bits);
598
599      // It is possible for the external suspend request to be cancelled
600      // (by a resume) before the actual suspend operation is completed.
601      // Refresh our local copy to see if we still need to wait.
602      pending = is_external_suspend();
603    }
604
605    if (!pending) {
606      // A cancelled suspend request is the only false return from
607      // is_ext_suspend_completed() that keeps us from staying in the
608      // retry loop.
609      *bits |= 0x00080000;
610      return false;
611    }
612
613    if (is_suspended) {
614      *bits |= 0x00100000;
615      return true;
616    }
617  } // end retry loop
618
619  // thread did not suspend after all our retries
620  *bits |= 0x00200000;
621  return false;
622}
623
624#ifndef PRODUCT
625void JavaThread::record_jump(address target, address instr, const char* file, int line) {
626
627  // This should not need to be atomic as the only way for simultaneous
628  // updates is via interrupts. Even then this should be rare or non-existant
629  // and we don't care that much anyway.
630
631  int index = _jmp_ring_index;
632  _jmp_ring_index = (index + 1 ) & (jump_ring_buffer_size - 1);
633  _jmp_ring[index]._target = (intptr_t) target;
634  _jmp_ring[index]._instruction = (intptr_t) instr;
635  _jmp_ring[index]._file = file;
636  _jmp_ring[index]._line = line;
637}
638#endif /* PRODUCT */
639
640// Called by flat profiler
641// Callers have already called wait_for_ext_suspend_completion
642// The assertion for that is currently too complex to put here:
643bool JavaThread::profile_last_Java_frame(frame* _fr) {
644  bool gotframe = false;
645  // self suspension saves needed state.
646  if (has_last_Java_frame() && _anchor.walkable()) {
647     *_fr = pd_last_frame();
648     gotframe = true;
649  }
650  return gotframe;
651}
652
653void Thread::interrupt(Thread* thread) {
654  trace("interrupt", thread);
655  debug_only(check_for_dangling_thread_pointer(thread);)
656  os::interrupt(thread);
657}
658
659bool Thread::is_interrupted(Thread* thread, bool clear_interrupted) {
660  trace("is_interrupted", thread);
661  debug_only(check_for_dangling_thread_pointer(thread);)
662  // Note:  If clear_interrupted==false, this simply fetches and
663  // returns the value of the field osthread()->interrupted().
664  return os::is_interrupted(thread, clear_interrupted);
665}
666
667
668// GC Support
669bool Thread::claim_oops_do_par_case(int strong_roots_parity) {
670  jint thread_parity = _oops_do_parity;
671  if (thread_parity != strong_roots_parity) {
672    jint res = Atomic::cmpxchg(strong_roots_parity, &_oops_do_parity, thread_parity);
673    if (res == thread_parity) return true;
674    else {
675      guarantee(res == strong_roots_parity, "Or else what?");
676      assert(SharedHeap::heap()->n_par_threads() > 0,
677             "Should only fail when parallel.");
678      return false;
679    }
680  }
681  assert(SharedHeap::heap()->n_par_threads() > 0,
682         "Should only fail when parallel.");
683  return false;
684}
685
686void Thread::oops_do(OopClosure* f) {
687  active_handles()->oops_do(f);
688  // Do oop for ThreadShadow
689  f->do_oop((oop*)&_pending_exception);
690  handle_area()->oops_do(f);
691}
692
693void Thread::nmethods_do() {
694}
695
696void Thread::print_on(outputStream* st) const {
697  // get_priority assumes osthread initialized
698  if (osthread() != NULL) {
699    st->print("prio=%d tid=" INTPTR_FORMAT " ", get_priority(this), this);
700    osthread()->print_on(st);
701  }
702  debug_only(if (WizardMode) print_owned_locks_on(st);)
703}
704
705// Thread::print_on_error() is called by fatal error handler. Don't use
706// any lock or allocate memory.
707void Thread::print_on_error(outputStream* st, char* buf, int buflen) const {
708  if      (is_VM_thread())                  st->print("VMThread");
709  else if (is_Compiler_thread())            st->print("CompilerThread");
710  else if (is_Java_thread())                st->print("JavaThread");
711  else if (is_GC_task_thread())             st->print("GCTaskThread");
712  else if (is_Watcher_thread())             st->print("WatcherThread");
713  else if (is_ConcurrentGC_thread())        st->print("ConcurrentGCThread");
714  else st->print("Thread");
715
716  st->print(" [stack: " PTR_FORMAT "," PTR_FORMAT "]",
717            _stack_base - _stack_size, _stack_base);
718
719  if (osthread()) {
720    st->print(" [id=%d]", osthread()->thread_id());
721  }
722}
723
724#ifdef ASSERT
725void Thread::print_owned_locks_on(outputStream* st) const {
726  Monitor *cur = _owned_locks;
727  if (cur == NULL) {
728    st->print(" (no locks) ");
729  } else {
730    st->print_cr(" Locks owned:");
731    while(cur) {
732      cur->print_on(st);
733      cur = cur->next();
734    }
735  }
736}
737
738static int ref_use_count  = 0;
739
740bool Thread::owns_locks_but_compiled_lock() const {
741  for(Monitor *cur = _owned_locks; cur; cur = cur->next()) {
742    if (cur != Compile_lock) return true;
743  }
744  return false;
745}
746
747
748#endif
749
750#ifndef PRODUCT
751
752// The flag: potential_vm_operation notifies if this particular safepoint state could potential
753// invoke the vm-thread (i.e., and oop allocation). In that case, we also have to make sure that
754// no threads which allow_vm_block's are held
755void Thread::check_for_valid_safepoint_state(bool potential_vm_operation) {
756    // Check if current thread is allowed to block at a safepoint
757    if (!(_allow_safepoint_count == 0))
758      fatal("Possible safepoint reached by thread that does not allow it");
759    if (is_Java_thread() && ((JavaThread*)this)->thread_state() != _thread_in_vm) {
760      fatal("LEAF method calling lock?");
761    }
762
763#ifdef ASSERT
764    if (potential_vm_operation && is_Java_thread()
765        && !Universe::is_bootstrapping()) {
766      // Make sure we do not hold any locks that the VM thread also uses.
767      // This could potentially lead to deadlocks
768      for(Monitor *cur = _owned_locks; cur; cur = cur->next()) {
769        // Threads_lock is special, since the safepoint synchronization will not start before this is
770        // acquired. Hence, a JavaThread cannot be holding it at a safepoint. So is VMOperationRequest_lock,
771        // since it is used to transfer control between JavaThreads and the VMThread
772        // Do not *exclude* any locks unless you are absolutly sure it is correct. Ask someone else first!
773        if ( (cur->allow_vm_block() &&
774              cur != Threads_lock &&
775              cur != Compile_lock &&               // Temporary: should not be necessary when we get spearate compilation
776              cur != VMOperationRequest_lock &&
777              cur != VMOperationQueue_lock) ||
778              cur->rank() == Mutex::special) {
779          warning("Thread holding lock at safepoint that vm can block on: %s", cur->name());
780        }
781      }
782    }
783
784    if (GCALotAtAllSafepoints) {
785      // We could enter a safepoint here and thus have a gc
786      InterfaceSupport::check_gc_alot();
787    }
788
789#endif
790}
791#endif
792
793bool Thread::lock_is_in_stack(address adr) const {
794  assert(Thread::current() == this, "lock_is_in_stack can only be called from current thread");
795  // High limit: highest_lock is set during thread execution
796  // Low  limit: address of the local variable dummy, rounded to 4K boundary.
797  // (The rounding helps finding threads in unsafe mode, even if the particular stack
798  // frame has been popped already.  Correct as long as stacks are at least 4K long and aligned.)
799  address end = os::current_stack_pointer();
800  if (_highest_lock >= adr && adr >= end) return true;
801
802  return false;
803}
804
805
806bool Thread::is_in_stack(address adr) const {
807  assert(Thread::current() == this, "is_in_stack can only be called from current thread");
808  address end = os::current_stack_pointer();
809  if (stack_base() >= adr && adr >= end) return true;
810
811  return false;
812}
813
814
815// We had to move these methods here, because vm threads get into ObjectSynchronizer::enter
816// However, there is a note in JavaThread::is_lock_owned() about the VM threads not being
817// used for compilation in the future. If that change is made, the need for these methods
818// should be revisited, and they should be removed if possible.
819
820bool Thread::is_lock_owned(address adr) const {
821  if (lock_is_in_stack(adr) ) return true;
822  return false;
823}
824
825bool Thread::set_as_starting_thread() {
826 // NOTE: this must be called inside the main thread.
827  return os::create_main_thread((JavaThread*)this);
828}
829
830static void initialize_class(symbolHandle class_name, TRAPS) {
831  klassOop klass = SystemDictionary::resolve_or_fail(class_name, true, CHECK);
832  instanceKlass::cast(klass)->initialize(CHECK);
833}
834
835
836// Creates the initial ThreadGroup
837static Handle create_initial_thread_group(TRAPS) {
838  klassOop k = SystemDictionary::resolve_or_fail(vmSymbolHandles::java_lang_ThreadGroup(), true, CHECK_NH);
839  instanceKlassHandle klass (THREAD, k);
840
841  Handle system_instance = klass->allocate_instance_handle(CHECK_NH);
842  {
843    JavaValue result(T_VOID);
844    JavaCalls::call_special(&result,
845                            system_instance,
846                            klass,
847                            vmSymbolHandles::object_initializer_name(),
848                            vmSymbolHandles::void_method_signature(),
849                            CHECK_NH);
850  }
851  Universe::set_system_thread_group(system_instance());
852
853  Handle main_instance = klass->allocate_instance_handle(CHECK_NH);
854  {
855    JavaValue result(T_VOID);
856    Handle string = java_lang_String::create_from_str("main", CHECK_NH);
857    JavaCalls::call_special(&result,
858                            main_instance,
859                            klass,
860                            vmSymbolHandles::object_initializer_name(),
861                            vmSymbolHandles::threadgroup_string_void_signature(),
862                            system_instance,
863                            string,
864                            CHECK_NH);
865  }
866  return main_instance;
867}
868
869// Creates the initial Thread
870static oop create_initial_thread(Handle thread_group, JavaThread* thread, TRAPS) {
871  klassOop k = SystemDictionary::resolve_or_fail(vmSymbolHandles::java_lang_Thread(), true, CHECK_NULL);
872  instanceKlassHandle klass (THREAD, k);
873  instanceHandle thread_oop = klass->allocate_instance_handle(CHECK_NULL);
874
875  java_lang_Thread::set_thread(thread_oop(), thread);
876  java_lang_Thread::set_priority(thread_oop(), NormPriority);
877  thread->set_threadObj(thread_oop());
878
879  Handle string = java_lang_String::create_from_str("main", CHECK_NULL);
880
881  JavaValue result(T_VOID);
882  JavaCalls::call_special(&result, thread_oop,
883                                   klass,
884                                   vmSymbolHandles::object_initializer_name(),
885                                   vmSymbolHandles::threadgroup_string_void_signature(),
886                                   thread_group,
887                                   string,
888                                   CHECK_NULL);
889  return thread_oop();
890}
891
892static void call_initializeSystemClass(TRAPS) {
893  klassOop k =  SystemDictionary::resolve_or_fail(vmSymbolHandles::java_lang_System(), true, CHECK);
894  instanceKlassHandle klass (THREAD, k);
895
896  JavaValue result(T_VOID);
897  JavaCalls::call_static(&result, klass, vmSymbolHandles::initializeSystemClass_name(),
898                                         vmSymbolHandles::void_method_signature(), CHECK);
899}
900
901static void reset_vm_info_property(TRAPS) {
902  // the vm info string
903  ResourceMark rm(THREAD);
904  const char *vm_info = VM_Version::vm_info_string();
905
906  // java.lang.System class
907  klassOop k =  SystemDictionary::resolve_or_fail(vmSymbolHandles::java_lang_System(), true, CHECK);
908  instanceKlassHandle klass (THREAD, k);
909
910  // setProperty arguments
911  Handle key_str    = java_lang_String::create_from_str("java.vm.info", CHECK);
912  Handle value_str  = java_lang_String::create_from_str(vm_info, CHECK);
913
914  // return value
915  JavaValue r(T_OBJECT);
916
917  // public static String setProperty(String key, String value);
918  JavaCalls::call_static(&r,
919                         klass,
920                         vmSymbolHandles::setProperty_name(),
921                         vmSymbolHandles::string_string_string_signature(),
922                         key_str,
923                         value_str,
924                         CHECK);
925}
926
927
928void JavaThread::allocate_threadObj(Handle thread_group, char* thread_name, bool daemon, TRAPS) {
929  assert(thread_group.not_null(), "thread group should be specified");
930  assert(threadObj() == NULL, "should only create Java thread object once");
931
932  klassOop k = SystemDictionary::resolve_or_fail(vmSymbolHandles::java_lang_Thread(), true, CHECK);
933  instanceKlassHandle klass (THREAD, k);
934  instanceHandle thread_oop = klass->allocate_instance_handle(CHECK);
935
936  java_lang_Thread::set_thread(thread_oop(), this);
937  java_lang_Thread::set_priority(thread_oop(), NormPriority);
938  set_threadObj(thread_oop());
939
940  JavaValue result(T_VOID);
941  if (thread_name != NULL) {
942    Handle name = java_lang_String::create_from_str(thread_name, CHECK);
943    // Thread gets assigned specified name and null target
944    JavaCalls::call_special(&result,
945                            thread_oop,
946                            klass,
947                            vmSymbolHandles::object_initializer_name(),
948                            vmSymbolHandles::threadgroup_string_void_signature(),
949                            thread_group, // Argument 1
950                            name,         // Argument 2
951                            THREAD);
952  } else {
953    // Thread gets assigned name "Thread-nnn" and null target
954    // (java.lang.Thread doesn't have a constructor taking only a ThreadGroup argument)
955    JavaCalls::call_special(&result,
956                            thread_oop,
957                            klass,
958                            vmSymbolHandles::object_initializer_name(),
959                            vmSymbolHandles::threadgroup_runnable_void_signature(),
960                            thread_group, // Argument 1
961                            Handle(),     // Argument 2
962                            THREAD);
963  }
964
965
966  if (daemon) {
967      java_lang_Thread::set_daemon(thread_oop());
968  }
969
970  if (HAS_PENDING_EXCEPTION) {
971    return;
972  }
973
974  KlassHandle group(this, SystemDictionary::threadGroup_klass());
975  Handle threadObj(this, this->threadObj());
976
977  JavaCalls::call_special(&result,
978                         thread_group,
979                         group,
980                         vmSymbolHandles::add_method_name(),
981                         vmSymbolHandles::thread_void_signature(),
982                         threadObj,          // Arg 1
983                         THREAD);
984
985
986}
987
988// NamedThread --  non-JavaThread subclasses with multiple
989// uniquely named instances should derive from this.
990NamedThread::NamedThread() : Thread() {
991  _name = NULL;
992}
993
994NamedThread::~NamedThread() {
995  if (_name != NULL) {
996    FREE_C_HEAP_ARRAY(char, _name);
997    _name = NULL;
998  }
999}
1000
1001void NamedThread::set_name(const char* format, ...) {
1002  guarantee(_name == NULL, "Only get to set name once.");
1003  _name = NEW_C_HEAP_ARRAY(char, max_name_len);
1004  guarantee(_name != NULL, "alloc failure");
1005  va_list ap;
1006  va_start(ap, format);
1007  jio_vsnprintf(_name, max_name_len, format, ap);
1008  va_end(ap);
1009}
1010
1011// ======= WatcherThread ========
1012
1013// The watcher thread exists to simulate timer interrupts.  It should
1014// be replaced by an abstraction over whatever native support for
1015// timer interrupts exists on the platform.
1016
1017WatcherThread* WatcherThread::_watcher_thread   = NULL;
1018bool           WatcherThread::_should_terminate = false;
1019
1020WatcherThread::WatcherThread() : Thread() {
1021  assert(watcher_thread() == NULL, "we can only allocate one WatcherThread");
1022  if (os::create_thread(this, os::watcher_thread)) {
1023    _watcher_thread = this;
1024
1025    // Set the watcher thread to the highest OS priority which should not be
1026    // used, unless a Java thread with priority java.lang.Thread.MAX_PRIORITY
1027    // is created. The only normal thread using this priority is the reference
1028    // handler thread, which runs for very short intervals only.
1029    // If the VMThread's priority is not lower than the WatcherThread profiling
1030    // will be inaccurate.
1031    os::set_priority(this, MaxPriority);
1032    if (!DisableStartThread) {
1033      os::start_thread(this);
1034    }
1035  }
1036}
1037
1038void WatcherThread::run() {
1039  assert(this == watcher_thread(), "just checking");
1040
1041  this->record_stack_base_and_size();
1042  this->initialize_thread_local_storage();
1043  this->set_active_handles(JNIHandleBlock::allocate_block());
1044  while(!_should_terminate) {
1045    assert(watcher_thread() == Thread::current(),  "thread consistency check");
1046    assert(watcher_thread() == this,  "thread consistency check");
1047
1048    // Calculate how long it'll be until the next PeriodicTask work
1049    // should be done, and sleep that amount of time.
1050    const size_t time_to_wait = PeriodicTask::time_to_wait();
1051    os::sleep(this, time_to_wait, false);
1052
1053    if (is_error_reported()) {
1054      // A fatal error has happened, the error handler(VMError::report_and_die)
1055      // should abort JVM after creating an error log file. However in some
1056      // rare cases, the error handler itself might deadlock. Here we try to
1057      // kill JVM if the fatal error handler fails to abort in 2 minutes.
1058      //
1059      // This code is in WatcherThread because WatcherThread wakes up
1060      // periodically so the fatal error handler doesn't need to do anything;
1061      // also because the WatcherThread is less likely to crash than other
1062      // threads.
1063
1064      for (;;) {
1065        if (!ShowMessageBoxOnError
1066         && (OnError == NULL || OnError[0] == '\0')
1067         && Arguments::abort_hook() == NULL) {
1068             os::sleep(this, 2 * 60 * 1000, false);
1069             fdStream err(defaultStream::output_fd());
1070             err.print_raw_cr("# [ timer expired, abort... ]");
1071             // skip atexit/vm_exit/vm_abort hooks
1072             os::die();
1073        }
1074
1075        // Wake up 5 seconds later, the fatal handler may reset OnError or
1076        // ShowMessageBoxOnError when it is ready to abort.
1077        os::sleep(this, 5 * 1000, false);
1078      }
1079    }
1080
1081    PeriodicTask::real_time_tick(time_to_wait);
1082
1083    // If we have no more tasks left due to dynamic disenrollment,
1084    // shut down the thread since we don't currently support dynamic enrollment
1085    if (PeriodicTask::num_tasks() == 0) {
1086      _should_terminate = true;
1087    }
1088  }
1089
1090  // Signal that it is terminated
1091  {
1092    MutexLockerEx mu(Terminator_lock, Mutex::_no_safepoint_check_flag);
1093    _watcher_thread = NULL;
1094    Terminator_lock->notify();
1095  }
1096
1097  // Thread destructor usually does this..
1098  ThreadLocalStorage::set_thread(NULL);
1099}
1100
1101void WatcherThread::start() {
1102  if (watcher_thread() == NULL) {
1103    _should_terminate = false;
1104    // Create the single instance of WatcherThread
1105    new WatcherThread();
1106  }
1107}
1108
1109void WatcherThread::stop() {
1110  // it is ok to take late safepoints here, if needed
1111  MutexLocker mu(Terminator_lock);
1112  _should_terminate = true;
1113  while(watcher_thread() != NULL) {
1114    // This wait should make safepoint checks, wait without a timeout,
1115    // and wait as a suspend-equivalent condition.
1116    //
1117    // Note: If the FlatProfiler is running, then this thread is waiting
1118    // for the WatcherThread to terminate and the WatcherThread, via the
1119    // FlatProfiler task, is waiting for the external suspend request on
1120    // this thread to complete. wait_for_ext_suspend_completion() will
1121    // eventually timeout, but that takes time. Making this wait a
1122    // suspend-equivalent condition solves that timeout problem.
1123    //
1124    Terminator_lock->wait(!Mutex::_no_safepoint_check_flag, 0,
1125                          Mutex::_as_suspend_equivalent_flag);
1126  }
1127}
1128
1129void WatcherThread::print_on(outputStream* st) const {
1130  st->print("\"%s\" ", name());
1131  Thread::print_on(st);
1132  st->cr();
1133}
1134
1135// ======= JavaThread ========
1136
1137// A JavaThread is a normal Java thread
1138
1139void JavaThread::initialize() {
1140  // Initialize fields
1141
1142  // Set the claimed par_id to -1 (ie not claiming any par_ids)
1143  set_claimed_par_id(-1);
1144
1145  set_saved_exception_pc(NULL);
1146  set_threadObj(NULL);
1147  _anchor.clear();
1148  set_entry_point(NULL);
1149  set_jni_functions(jni_functions());
1150  set_callee_target(NULL);
1151  set_vm_result(NULL);
1152  set_vm_result_2(NULL);
1153  set_vframe_array_head(NULL);
1154  set_vframe_array_last(NULL);
1155  set_deferred_locals(NULL);
1156  set_deopt_mark(NULL);
1157  clear_must_deopt_id();
1158  set_monitor_chunks(NULL);
1159  set_next(NULL);
1160  set_thread_state(_thread_new);
1161  _terminated = _not_terminated;
1162  _privileged_stack_top = NULL;
1163  _array_for_gc = NULL;
1164  _suspend_equivalent = false;
1165  _in_deopt_handler = 0;
1166  _doing_unsafe_access = false;
1167  _stack_guard_state = stack_guard_unused;
1168  _exception_oop = NULL;
1169  _exception_pc  = 0;
1170  _exception_handler_pc = 0;
1171  _exception_stack_size = 0;
1172  _jvmti_thread_state= NULL;
1173  _jvmti_get_loaded_classes_closure = NULL;
1174  _interp_only_mode    = 0;
1175  _special_runtime_exit_condition = _no_async_condition;
1176  _pending_async_exception = NULL;
1177  _is_compiling = false;
1178  _thread_stat = NULL;
1179  _thread_stat = new ThreadStatistics();
1180  _blocked_on_compilation = false;
1181  _jni_active_critical = 0;
1182  _do_not_unlock_if_synchronized = false;
1183  _cached_monitor_info = NULL;
1184  _parker = Parker::Allocate(this) ;
1185
1186#ifndef PRODUCT
1187  _jmp_ring_index = 0;
1188  for (int ji = 0 ; ji < jump_ring_buffer_size ; ji++ ) {
1189    record_jump(NULL, NULL, NULL, 0);
1190  }
1191#endif /* PRODUCT */
1192
1193  set_thread_profiler(NULL);
1194  if (FlatProfiler::is_active()) {
1195    // This is where we would decide to either give each thread it's own profiler
1196    // or use one global one from FlatProfiler,
1197    // or up to some count of the number of profiled threads, etc.
1198    ThreadProfiler* pp = new ThreadProfiler();
1199    pp->engage();
1200    set_thread_profiler(pp);
1201  }
1202
1203  // Setup safepoint state info for this thread
1204  ThreadSafepointState::create(this);
1205
1206  debug_only(_java_call_counter = 0);
1207
1208  // JVMTI PopFrame support
1209  _popframe_condition = popframe_inactive;
1210  _popframe_preserved_args = NULL;
1211  _popframe_preserved_args_size = 0;
1212
1213  pd_initialize();
1214}
1215
1216#ifndef SERIALGC
1217SATBMarkQueueSet JavaThread::_satb_mark_queue_set;
1218DirtyCardQueueSet JavaThread::_dirty_card_queue_set;
1219#endif // !SERIALGC
1220
1221JavaThread::JavaThread(bool is_attaching) :
1222  Thread()
1223#ifndef SERIALGC
1224  , _satb_mark_queue(&_satb_mark_queue_set),
1225  _dirty_card_queue(&_dirty_card_queue_set)
1226#endif // !SERIALGC
1227{
1228  initialize();
1229  _is_attaching = is_attaching;
1230}
1231
1232bool JavaThread::reguard_stack(address cur_sp) {
1233  if (_stack_guard_state != stack_guard_yellow_disabled) {
1234    return true; // Stack already guarded or guard pages not needed.
1235  }
1236
1237  if (register_stack_overflow()) {
1238    // For those architectures which have separate register and
1239    // memory stacks, we must check the register stack to see if
1240    // it has overflowed.
1241    return false;
1242  }
1243
1244  // Java code never executes within the yellow zone: the latter is only
1245  // there to provoke an exception during stack banging.  If java code
1246  // is executing there, either StackShadowPages should be larger, or
1247  // some exception code in c1, c2 or the interpreter isn't unwinding
1248  // when it should.
1249  guarantee(cur_sp > stack_yellow_zone_base(), "not enough space to reguard - increase StackShadowPages");
1250
1251  enable_stack_yellow_zone();
1252  return true;
1253}
1254
1255bool JavaThread::reguard_stack(void) {
1256  return reguard_stack(os::current_stack_pointer());
1257}
1258
1259
1260void JavaThread::block_if_vm_exited() {
1261  if (_terminated == _vm_exited) {
1262    // _vm_exited is set at safepoint, and Threads_lock is never released
1263    // we will block here forever
1264    Threads_lock->lock_without_safepoint_check();
1265    ShouldNotReachHere();
1266  }
1267}
1268
1269
1270// Remove this ifdef when C1 is ported to the compiler interface.
1271static void compiler_thread_entry(JavaThread* thread, TRAPS);
1272
1273JavaThread::JavaThread(ThreadFunction entry_point, size_t stack_sz) :
1274  Thread()
1275#ifndef SERIALGC
1276  , _satb_mark_queue(&_satb_mark_queue_set),
1277  _dirty_card_queue(&_dirty_card_queue_set)
1278#endif // !SERIALGC
1279{
1280  if (TraceThreadEvents) {
1281    tty->print_cr("creating thread %p", this);
1282  }
1283  initialize();
1284  _is_attaching = false;
1285  set_entry_point(entry_point);
1286  // Create the native thread itself.
1287  // %note runtime_23
1288  os::ThreadType thr_type = os::java_thread;
1289  thr_type = entry_point == &compiler_thread_entry ? os::compiler_thread :
1290                                                     os::java_thread;
1291  os::create_thread(this, thr_type, stack_sz);
1292
1293  // The _osthread may be NULL here because we ran out of memory (too many threads active).
1294  // We need to throw and OutOfMemoryError - however we cannot do this here because the caller
1295  // may hold a lock and all locks must be unlocked before throwing the exception (throwing
1296  // the exception consists of creating the exception object & initializing it, initialization
1297  // will leave the VM via a JavaCall and then all locks must be unlocked).
1298  //
1299  // The thread is still suspended when we reach here. Thread must be explicit started
1300  // by creator! Furthermore, the thread must also explicitly be added to the Threads list
1301  // by calling Threads:add. The reason why this is not done here, is because the thread
1302  // object must be fully initialized (take a look at JVM_Start)
1303}
1304
1305JavaThread::~JavaThread() {
1306  if (TraceThreadEvents) {
1307      tty->print_cr("terminate thread %p", this);
1308  }
1309
1310  // JSR166 -- return the parker to the free list
1311  Parker::Release(_parker);
1312  _parker = NULL ;
1313
1314  // Free any remaining  previous UnrollBlock
1315  vframeArray* old_array = vframe_array_last();
1316
1317  if (old_array != NULL) {
1318    Deoptimization::UnrollBlock* old_info = old_array->unroll_block();
1319    old_array->set_unroll_block(NULL);
1320    delete old_info;
1321    delete old_array;
1322  }
1323
1324  GrowableArray<jvmtiDeferredLocalVariableSet*>* deferred = deferred_locals();
1325  if (deferred != NULL) {
1326    // This can only happen if thread is destroyed before deoptimization occurs.
1327    assert(deferred->length() != 0, "empty array!");
1328    do {
1329      jvmtiDeferredLocalVariableSet* dlv = deferred->at(0);
1330      deferred->remove_at(0);
1331      // individual jvmtiDeferredLocalVariableSet are CHeapObj's
1332      delete dlv;
1333    } while (deferred->length() != 0);
1334    delete deferred;
1335  }
1336
1337  // All Java related clean up happens in exit
1338  ThreadSafepointState::destroy(this);
1339  if (_thread_profiler != NULL) delete _thread_profiler;
1340  if (_thread_stat != NULL) delete _thread_stat;
1341}
1342
1343
1344// The first routine called by a new Java thread
1345void JavaThread::run() {
1346  // initialize thread-local alloc buffer related fields
1347  this->initialize_tlab();
1348
1349  // used to test validitity of stack trace backs
1350  this->record_base_of_stack_pointer();
1351
1352  // Record real stack base and size.
1353  this->record_stack_base_and_size();
1354
1355  // Initialize thread local storage; set before calling MutexLocker
1356  this->initialize_thread_local_storage();
1357
1358  this->create_stack_guard_pages();
1359
1360  // Thread is now sufficient initialized to be handled by the safepoint code as being
1361  // in the VM. Change thread state from _thread_new to _thread_in_vm
1362  ThreadStateTransition::transition_and_fence(this, _thread_new, _thread_in_vm);
1363
1364  assert(JavaThread::current() == this, "sanity check");
1365  assert(!Thread::current()->owns_locks(), "sanity check");
1366
1367  DTRACE_THREAD_PROBE(start, this);
1368
1369  // This operation might block. We call that after all safepoint checks for a new thread has
1370  // been completed.
1371  this->set_active_handles(JNIHandleBlock::allocate_block());
1372
1373  if (JvmtiExport::should_post_thread_life()) {
1374    JvmtiExport::post_thread_start(this);
1375  }
1376
1377  // We call another function to do the rest so we are sure that the stack addresses used
1378  // from there will be lower than the stack base just computed
1379  thread_main_inner();
1380
1381  // Note, thread is no longer valid at this point!
1382}
1383
1384
1385void JavaThread::thread_main_inner() {
1386  assert(JavaThread::current() == this, "sanity check");
1387  assert(this->threadObj() != NULL, "just checking");
1388
1389  // Execute thread entry point. If this thread is being asked to restart,
1390  // or has been stopped before starting, do not reexecute entry point.
1391  // Note: Due to JVM_StopThread we can have pending exceptions already!
1392  if (!this->has_pending_exception() && !java_lang_Thread::is_stillborn(this->threadObj())) {
1393    // enter the thread's entry point only if we have no pending exceptions
1394    HandleMark hm(this);
1395    this->entry_point()(this, this);
1396  }
1397
1398  DTRACE_THREAD_PROBE(stop, this);
1399
1400  this->exit(false);
1401  delete this;
1402}
1403
1404
1405static void ensure_join(JavaThread* thread) {
1406  // We do not need to grap the Threads_lock, since we are operating on ourself.
1407  Handle threadObj(thread, thread->threadObj());
1408  assert(threadObj.not_null(), "java thread object must exist");
1409  ObjectLocker lock(threadObj, thread);
1410  // Ignore pending exception (ThreadDeath), since we are exiting anyway
1411  thread->clear_pending_exception();
1412  // It is of profound importance that we set the stillborn bit and reset the thread object,
1413  // before we do the notify. Since, changing these two variable will make JVM_IsAlive return
1414  // false. So in case another thread is doing a join on this thread , it will detect that the thread
1415  // is dead when it gets notified.
1416  java_lang_Thread::set_stillborn(threadObj());
1417  // Thread is exiting. So set thread_status field in  java.lang.Thread class to TERMINATED.
1418  java_lang_Thread::set_thread_status(threadObj(), java_lang_Thread::TERMINATED);
1419  java_lang_Thread::set_thread(threadObj(), NULL);
1420  lock.notify_all(thread);
1421  // Ignore pending exception (ThreadDeath), since we are exiting anyway
1422  thread->clear_pending_exception();
1423}
1424
1425// For any new cleanup additions, please check to see if they need to be applied to
1426// cleanup_failed_attach_current_thread as well.
1427void JavaThread::exit(bool destroy_vm, ExitType exit_type) {
1428  assert(this == JavaThread::current(),  "thread consistency check");
1429  if (!InitializeJavaLangSystem) return;
1430
1431  HandleMark hm(this);
1432  Handle uncaught_exception(this, this->pending_exception());
1433  this->clear_pending_exception();
1434  Handle threadObj(this, this->threadObj());
1435  assert(threadObj.not_null(), "Java thread object should be created");
1436
1437  if (get_thread_profiler() != NULL) {
1438    get_thread_profiler()->disengage();
1439    ResourceMark rm;
1440    get_thread_profiler()->print(get_thread_name());
1441  }
1442
1443
1444  // FIXIT: This code should be moved into else part, when reliable 1.2/1.3 check is in place
1445  {
1446    EXCEPTION_MARK;
1447
1448    CLEAR_PENDING_EXCEPTION;
1449  }
1450  // FIXIT: The is_null check is only so it works better on JDK1.2 VM's. This
1451  // has to be fixed by a runtime query method
1452  if (!destroy_vm || JDK_Version::is_jdk12x_version()) {
1453    // JSR-166: change call from from ThreadGroup.uncaughtException to
1454    // java.lang.Thread.dispatchUncaughtException
1455    if (uncaught_exception.not_null()) {
1456      Handle group(this, java_lang_Thread::threadGroup(threadObj()));
1457      Events::log("uncaught exception INTPTR_FORMAT " " INTPTR_FORMAT " " INTPTR_FORMAT",
1458        (address)uncaught_exception(), (address)threadObj(), (address)group());
1459      {
1460        EXCEPTION_MARK;
1461        // Check if the method Thread.dispatchUncaughtException() exists. If so
1462        // call it.  Otherwise we have an older library without the JSR-166 changes,
1463        // so call ThreadGroup.uncaughtException()
1464        KlassHandle recvrKlass(THREAD, threadObj->klass());
1465        CallInfo callinfo;
1466        KlassHandle thread_klass(THREAD, SystemDictionary::thread_klass());
1467        LinkResolver::resolve_virtual_call(callinfo, threadObj, recvrKlass, thread_klass,
1468                                           vmSymbolHandles::dispatchUncaughtException_name(),
1469                                           vmSymbolHandles::throwable_void_signature(),
1470                                           KlassHandle(), false, false, THREAD);
1471        CLEAR_PENDING_EXCEPTION;
1472        methodHandle method = callinfo.selected_method();
1473        if (method.not_null()) {
1474          JavaValue result(T_VOID);
1475          JavaCalls::call_virtual(&result,
1476                                  threadObj, thread_klass,
1477                                  vmSymbolHandles::dispatchUncaughtException_name(),
1478                                  vmSymbolHandles::throwable_void_signature(),
1479                                  uncaught_exception,
1480                                  THREAD);
1481        } else {
1482          KlassHandle thread_group(THREAD, SystemDictionary::threadGroup_klass());
1483          JavaValue result(T_VOID);
1484          JavaCalls::call_virtual(&result,
1485                                  group, thread_group,
1486                                  vmSymbolHandles::uncaughtException_name(),
1487                                  vmSymbolHandles::thread_throwable_void_signature(),
1488                                  threadObj,           // Arg 1
1489                                  uncaught_exception,  // Arg 2
1490                                  THREAD);
1491        }
1492        CLEAR_PENDING_EXCEPTION;
1493      }
1494    }
1495
1496    // Call Thread.exit(). We try 3 times in case we got another Thread.stop during
1497    // the execution of the method. If that is not enough, then we don't really care. Thread.stop
1498    // is deprecated anyhow.
1499    { int count = 3;
1500      while (java_lang_Thread::threadGroup(threadObj()) != NULL && (count-- > 0)) {
1501        EXCEPTION_MARK;
1502        JavaValue result(T_VOID);
1503        KlassHandle thread_klass(THREAD, SystemDictionary::thread_klass());
1504        JavaCalls::call_virtual(&result,
1505                              threadObj, thread_klass,
1506                              vmSymbolHandles::exit_method_name(),
1507                              vmSymbolHandles::void_method_signature(),
1508                              THREAD);
1509        CLEAR_PENDING_EXCEPTION;
1510      }
1511    }
1512
1513    // notify JVMTI
1514    if (JvmtiExport::should_post_thread_life()) {
1515      JvmtiExport::post_thread_end(this);
1516    }
1517
1518    // We have notified the agents that we are exiting, before we go on,
1519    // we must check for a pending external suspend request and honor it
1520    // in order to not surprise the thread that made the suspend request.
1521    while (true) {
1522      {
1523        MutexLockerEx ml(SR_lock(), Mutex::_no_safepoint_check_flag);
1524        if (!is_external_suspend()) {
1525          set_terminated(_thread_exiting);
1526          ThreadService::current_thread_exiting(this);
1527          break;
1528        }
1529        // Implied else:
1530        // Things get a little tricky here. We have a pending external
1531        // suspend request, but we are holding the SR_lock so we
1532        // can't just self-suspend. So we temporarily drop the lock
1533        // and then self-suspend.
1534      }
1535
1536      ThreadBlockInVM tbivm(this);
1537      java_suspend_self();
1538
1539      // We're done with this suspend request, but we have to loop around
1540      // and check again. Eventually we will get SR_lock without a pending
1541      // external suspend request and will be able to mark ourselves as
1542      // exiting.
1543    }
1544    // no more external suspends are allowed at this point
1545  } else {
1546    // before_exit() has already posted JVMTI THREAD_END events
1547  }
1548
1549  // Notify waiters on thread object. This has to be done after exit() is called
1550  // on the thread (if the thread is the last thread in a daemon ThreadGroup the
1551  // group should have the destroyed bit set before waiters are notified).
1552  ensure_join(this);
1553  assert(!this->has_pending_exception(), "ensure_join should have cleared");
1554
1555  // 6282335 JNI DetachCurrentThread spec states that all Java monitors
1556  // held by this thread must be released.  A detach operation must only
1557  // get here if there are no Java frames on the stack.  Therefore, any
1558  // owned monitors at this point MUST be JNI-acquired monitors which are
1559  // pre-inflated and in the monitor cache.
1560  //
1561  // ensure_join() ignores IllegalThreadStateExceptions, and so does this.
1562  if (exit_type == jni_detach && JNIDetachReleasesMonitors) {
1563    assert(!this->has_last_Java_frame(), "detaching with Java frames?");
1564    ObjectSynchronizer::release_monitors_owned_by_thread(this);
1565    assert(!this->has_pending_exception(), "release_monitors should have cleared");
1566  }
1567
1568  // These things needs to be done while we are still a Java Thread. Make sure that thread
1569  // is in a consistent state, in case GC happens
1570  assert(_privileged_stack_top == NULL, "must be NULL when we get here");
1571
1572  if (active_handles() != NULL) {
1573    JNIHandleBlock* block = active_handles();
1574    set_active_handles(NULL);
1575    JNIHandleBlock::release_block(block);
1576  }
1577
1578  if (free_handle_block() != NULL) {
1579    JNIHandleBlock* block = free_handle_block();
1580    set_free_handle_block(NULL);
1581    JNIHandleBlock::release_block(block);
1582  }
1583
1584  // These have to be removed while this is still a valid thread.
1585  remove_stack_guard_pages();
1586
1587  if (UseTLAB) {
1588    tlab().make_parsable(true);  // retire TLAB
1589  }
1590
1591  if (jvmti_thread_state() != NULL) {
1592    JvmtiExport::cleanup_thread(this);
1593  }
1594
1595  // Remove from list of active threads list, and notify VM thread if we are the last non-daemon thread
1596  Threads::remove(this);
1597}
1598
1599void JavaThread::cleanup_failed_attach_current_thread() {
1600
1601     if (get_thread_profiler() != NULL) {
1602       get_thread_profiler()->disengage();
1603       ResourceMark rm;
1604       get_thread_profiler()->print(get_thread_name());
1605     }
1606
1607     if (active_handles() != NULL) {
1608      JNIHandleBlock* block = active_handles();
1609      set_active_handles(NULL);
1610      JNIHandleBlock::release_block(block);
1611     }
1612
1613     if (free_handle_block() != NULL) {
1614       JNIHandleBlock* block = free_handle_block();
1615       set_free_handle_block(NULL);
1616       JNIHandleBlock::release_block(block);
1617     }
1618
1619     if (UseTLAB) {
1620       tlab().make_parsable(true);  // retire TLAB, if any
1621     }
1622
1623     Threads::remove(this);
1624     delete this;
1625}
1626
1627
1628JavaThread* JavaThread::active() {
1629  Thread* thread = ThreadLocalStorage::thread();
1630  assert(thread != NULL, "just checking");
1631  if (thread->is_Java_thread()) {
1632    return (JavaThread*) thread;
1633  } else {
1634    assert(thread->is_VM_thread(), "this must be a vm thread");
1635    VM_Operation* op = ((VMThread*) thread)->vm_operation();
1636    JavaThread *ret=op == NULL ? NULL : (JavaThread *)op->calling_thread();
1637    assert(ret->is_Java_thread(), "must be a Java thread");
1638    return ret;
1639  }
1640}
1641
1642bool JavaThread::is_lock_owned(address adr) const {
1643  if (lock_is_in_stack(adr)) return true;
1644
1645  for (MonitorChunk* chunk = monitor_chunks(); chunk != NULL; chunk = chunk->next()) {
1646    if (chunk->contains(adr)) return true;
1647  }
1648
1649  return false;
1650}
1651
1652
1653void JavaThread::add_monitor_chunk(MonitorChunk* chunk) {
1654  chunk->set_next(monitor_chunks());
1655  set_monitor_chunks(chunk);
1656}
1657
1658void JavaThread::remove_monitor_chunk(MonitorChunk* chunk) {
1659  guarantee(monitor_chunks() != NULL, "must be non empty");
1660  if (monitor_chunks() == chunk) {
1661    set_monitor_chunks(chunk->next());
1662  } else {
1663    MonitorChunk* prev = monitor_chunks();
1664    while (prev->next() != chunk) prev = prev->next();
1665    prev->set_next(chunk->next());
1666  }
1667}
1668
1669// JVM support.
1670
1671// Note: this function shouldn't block if it's called in
1672// _thread_in_native_trans state (such as from
1673// check_special_condition_for_native_trans()).
1674void JavaThread::check_and_handle_async_exceptions(bool check_unsafe_error) {
1675
1676  if (has_last_Java_frame() && has_async_condition()) {
1677    // If we are at a polling page safepoint (not a poll return)
1678    // then we must defer async exception because live registers
1679    // will be clobbered by the exception path. Poll return is
1680    // ok because the call we a returning from already collides
1681    // with exception handling registers and so there is no issue.
1682    // (The exception handling path kills call result registers but
1683    //  this is ok since the exception kills the result anyway).
1684
1685    if (is_at_poll_safepoint()) {
1686      // if the code we are returning to has deoptimized we must defer
1687      // the exception otherwise live registers get clobbered on the
1688      // exception path before deoptimization is able to retrieve them.
1689      //
1690      RegisterMap map(this, false);
1691      frame caller_fr = last_frame().sender(&map);
1692      assert(caller_fr.is_compiled_frame(), "what?");
1693      if (caller_fr.is_deoptimized_frame()) {
1694        if (TraceExceptions) {
1695          ResourceMark rm;
1696          tty->print_cr("deferred async exception at compiled safepoint");
1697        }
1698        return;
1699      }
1700    }
1701  }
1702
1703  JavaThread::AsyncRequests condition = clear_special_runtime_exit_condition();
1704  if (condition == _no_async_condition) {
1705    // Conditions have changed since has_special_runtime_exit_condition()
1706    // was called:
1707    // - if we were here only because of an external suspend request,
1708    //   then that was taken care of above (or cancelled) so we are done
1709    // - if we were here because of another async request, then it has
1710    //   been cleared between the has_special_runtime_exit_condition()
1711    //   and now so again we are done
1712    return;
1713  }
1714
1715  // Check for pending async. exception
1716  if (_pending_async_exception != NULL) {
1717    // Only overwrite an already pending exception, if it is not a threadDeath.
1718    if (!has_pending_exception() || !pending_exception()->is_a(SystemDictionary::threaddeath_klass())) {
1719
1720      // We cannot call Exceptions::_throw(...) here because we cannot block
1721      set_pending_exception(_pending_async_exception, __FILE__, __LINE__);
1722
1723      if (TraceExceptions) {
1724        ResourceMark rm;
1725        tty->print("Async. exception installed at runtime exit (" INTPTR_FORMAT ")", this);
1726        if (has_last_Java_frame() ) {
1727          frame f = last_frame();
1728          tty->print(" (pc: " INTPTR_FORMAT " sp: " INTPTR_FORMAT " )", f.pc(), f.sp());
1729        }
1730        tty->print_cr(" of type: %s", instanceKlass::cast(_pending_async_exception->klass())->external_name());
1731      }
1732      _pending_async_exception = NULL;
1733      clear_has_async_exception();
1734    }
1735  }
1736
1737  if (check_unsafe_error &&
1738      condition == _async_unsafe_access_error && !has_pending_exception()) {
1739    condition = _no_async_condition;  // done
1740    switch (thread_state()) {
1741    case _thread_in_vm:
1742      {
1743        JavaThread* THREAD = this;
1744        THROW_MSG(vmSymbols::java_lang_InternalError(), "a fault occurred in an unsafe memory access operation");
1745      }
1746    case _thread_in_native:
1747      {
1748        ThreadInVMfromNative tiv(this);
1749        JavaThread* THREAD = this;
1750        THROW_MSG(vmSymbols::java_lang_InternalError(), "a fault occurred in an unsafe memory access operation");
1751      }
1752    case _thread_in_Java:
1753      {
1754        ThreadInVMfromJava tiv(this);
1755        JavaThread* THREAD = this;
1756        THROW_MSG(vmSymbols::java_lang_InternalError(), "a fault occurred in a recent unsafe memory access operation in compiled Java code");
1757      }
1758    default:
1759      ShouldNotReachHere();
1760    }
1761  }
1762
1763  assert(condition == _no_async_condition || has_pending_exception() ||
1764         (!check_unsafe_error && condition == _async_unsafe_access_error),
1765         "must have handled the async condition, if no exception");
1766}
1767
1768void JavaThread::handle_special_runtime_exit_condition(bool check_asyncs) {
1769  //
1770  // Check for pending external suspend. Internal suspend requests do
1771  // not use handle_special_runtime_exit_condition().
1772  // If JNIEnv proxies are allowed, don't self-suspend if the target
1773  // thread is not the current thread. In older versions of jdbx, jdbx
1774  // threads could call into the VM with another thread's JNIEnv so we
1775  // can be here operating on behalf of a suspended thread (4432884).
1776  bool do_self_suspend = is_external_suspend_with_lock();
1777  if (do_self_suspend && (!AllowJNIEnvProxy || this == JavaThread::current())) {
1778    //
1779    // Because thread is external suspended the safepoint code will count
1780    // thread as at a safepoint. This can be odd because we can be here
1781    // as _thread_in_Java which would normally transition to _thread_blocked
1782    // at a safepoint. We would like to mark the thread as _thread_blocked
1783    // before calling java_suspend_self like all other callers of it but
1784    // we must then observe proper safepoint protocol. (We can't leave
1785    // _thread_blocked with a safepoint in progress). However we can be
1786    // here as _thread_in_native_trans so we can't use a normal transition
1787    // constructor/destructor pair because they assert on that type of
1788    // transition. We could do something like:
1789    //
1790    // JavaThreadState state = thread_state();
1791    // set_thread_state(_thread_in_vm);
1792    // {
1793    //   ThreadBlockInVM tbivm(this);
1794    //   java_suspend_self()
1795    // }
1796    // set_thread_state(_thread_in_vm_trans);
1797    // if (safepoint) block;
1798    // set_thread_state(state);
1799    //
1800    // but that is pretty messy. Instead we just go with the way the
1801    // code has worked before and note that this is the only path to
1802    // java_suspend_self that doesn't put the thread in _thread_blocked
1803    // mode.
1804
1805    frame_anchor()->make_walkable(this);
1806    java_suspend_self();
1807
1808    // We might be here for reasons in addition to the self-suspend request
1809    // so check for other async requests.
1810  }
1811
1812  if (check_asyncs) {
1813    check_and_handle_async_exceptions();
1814  }
1815}
1816
1817void JavaThread::send_thread_stop(oop java_throwable)  {
1818  assert(Thread::current()->is_VM_thread(), "should be in the vm thread");
1819  assert(Threads_lock->is_locked(), "Threads_lock should be locked by safepoint code");
1820  assert(SafepointSynchronize::is_at_safepoint(), "all threads are stopped");
1821
1822  // Do not throw asynchronous exceptions against the compiler thread
1823  // (the compiler thread should not be a Java thread -- fix in 1.4.2)
1824  if (is_Compiler_thread()) return;
1825
1826  // This is a change from JDK 1.1, but JDK 1.2 will also do it:
1827  if (java_throwable->is_a(SystemDictionary::threaddeath_klass())) {
1828    java_lang_Thread::set_stillborn(threadObj());
1829  }
1830
1831  {
1832    // Actually throw the Throwable against the target Thread - however
1833    // only if there is no thread death exception installed already.
1834    if (_pending_async_exception == NULL || !_pending_async_exception->is_a(SystemDictionary::threaddeath_klass())) {
1835      // If the topmost frame is a runtime stub, then we are calling into
1836      // OptoRuntime from compiled code. Some runtime stubs (new, monitor_exit..)
1837      // must deoptimize the caller before continuing, as the compiled  exception handler table
1838      // may not be valid
1839      if (has_last_Java_frame()) {
1840        frame f = last_frame();
1841        if (f.is_runtime_frame() || f.is_safepoint_blob_frame()) {
1842          // BiasedLocking needs an updated RegisterMap for the revoke monitors pass
1843          RegisterMap reg_map(this, UseBiasedLocking);
1844          frame compiled_frame = f.sender(&reg_map);
1845          if (compiled_frame.can_be_deoptimized()) {
1846            Deoptimization::deoptimize(this, compiled_frame, &reg_map);
1847          }
1848        }
1849      }
1850
1851      // Set async. pending exception in thread.
1852      set_pending_async_exception(java_throwable);
1853
1854      if (TraceExceptions) {
1855       ResourceMark rm;
1856       tty->print_cr("Pending Async. exception installed of type: %s", instanceKlass::cast(_pending_async_exception->klass())->external_name());
1857      }
1858      // for AbortVMOnException flag
1859      NOT_PRODUCT(Exceptions::debug_check_abort(instanceKlass::cast(_pending_async_exception->klass())->external_name()));
1860    }
1861  }
1862
1863
1864  // Interrupt thread so it will wake up from a potential wait()
1865  Thread::interrupt(this);
1866}
1867
1868// External suspension mechanism.
1869//
1870// Tell the VM to suspend a thread when ever it knows that it does not hold on
1871// to any VM_locks and it is at a transition
1872// Self-suspension will happen on the transition out of the vm.
1873// Catch "this" coming in from JNIEnv pointers when the thread has been freed
1874//
1875// Guarantees on return:
1876//   + Target thread will not execute any new bytecode (that's why we need to
1877//     force a safepoint)
1878//   + Target thread will not enter any new monitors
1879//
1880void JavaThread::java_suspend() {
1881  { MutexLocker mu(Threads_lock);
1882    if (!Threads::includes(this) || is_exiting() || this->threadObj() == NULL) {
1883       return;
1884    }
1885  }
1886
1887  { MutexLockerEx ml(SR_lock(), Mutex::_no_safepoint_check_flag);
1888    if (!is_external_suspend()) {
1889      // a racing resume has cancelled us; bail out now
1890      return;
1891    }
1892
1893    // suspend is done
1894    uint32_t debug_bits = 0;
1895    // Warning: is_ext_suspend_completed() may temporarily drop the
1896    // SR_lock to allow the thread to reach a stable thread state if
1897    // it is currently in a transient thread state.
1898    if (is_ext_suspend_completed(false /* !called_by_wait */,
1899                                 SuspendRetryDelay, &debug_bits) ) {
1900      return;
1901    }
1902  }
1903
1904  VM_ForceSafepoint vm_suspend;
1905  VMThread::execute(&vm_suspend);
1906}
1907
1908// Part II of external suspension.
1909// A JavaThread self suspends when it detects a pending external suspend
1910// request. This is usually on transitions. It is also done in places
1911// where continuing to the next transition would surprise the caller,
1912// e.g., monitor entry.
1913//
1914// Returns the number of times that the thread self-suspended.
1915//
1916// Note: DO NOT call java_suspend_self() when you just want to block current
1917//       thread. java_suspend_self() is the second stage of cooperative
1918//       suspension for external suspend requests and should only be used
1919//       to complete an external suspend request.
1920//
1921int JavaThread::java_suspend_self() {
1922  int ret = 0;
1923
1924  // we are in the process of exiting so don't suspend
1925  if (is_exiting()) {
1926     clear_external_suspend();
1927     return ret;
1928  }
1929
1930  assert(_anchor.walkable() ||
1931    (is_Java_thread() && !((JavaThread*)this)->has_last_Java_frame()),
1932    "must have walkable stack");
1933
1934  MutexLockerEx ml(SR_lock(), Mutex::_no_safepoint_check_flag);
1935
1936  assert(!this->is_any_suspended(),
1937    "a thread trying to self-suspend should not already be suspended");
1938
1939  if (this->is_suspend_equivalent()) {
1940    // If we are self-suspending as a result of the lifting of a
1941    // suspend equivalent condition, then the suspend_equivalent
1942    // flag is not cleared until we set the ext_suspended flag so
1943    // that wait_for_ext_suspend_completion() returns consistent
1944    // results.
1945    this->clear_suspend_equivalent();
1946  }
1947
1948  // A racing resume may have cancelled us before we grabbed SR_lock
1949  // above. Or another external suspend request could be waiting for us
1950  // by the time we return from SR_lock()->wait(). The thread
1951  // that requested the suspension may already be trying to walk our
1952  // stack and if we return now, we can change the stack out from under
1953  // it. This would be a "bad thing (TM)" and cause the stack walker
1954  // to crash. We stay self-suspended until there are no more pending
1955  // external suspend requests.
1956  while (is_external_suspend()) {
1957    ret++;
1958    this->set_ext_suspended();
1959
1960    // _ext_suspended flag is cleared by java_resume()
1961    while (is_ext_suspended()) {
1962      this->SR_lock()->wait(Mutex::_no_safepoint_check_flag);
1963    }
1964  }
1965
1966  return ret;
1967}
1968
1969#ifdef ASSERT
1970// verify the JavaThread has not yet been published in the Threads::list, and
1971// hence doesn't need protection from concurrent access at this stage
1972void JavaThread::verify_not_published() {
1973  if (!Threads_lock->owned_by_self()) {
1974   MutexLockerEx ml(Threads_lock,  Mutex::_no_safepoint_check_flag);
1975   assert( !Threads::includes(this),
1976           "java thread shouldn't have been published yet!");
1977  }
1978  else {
1979   assert( !Threads::includes(this),
1980           "java thread shouldn't have been published yet!");
1981  }
1982}
1983#endif
1984
1985// Slow path when the native==>VM/Java barriers detect a safepoint is in
1986// progress or when _suspend_flags is non-zero.
1987// Current thread needs to self-suspend if there is a suspend request and/or
1988// block if a safepoint is in progress.
1989// Async exception ISN'T checked.
1990// Note only the ThreadInVMfromNative transition can call this function
1991// directly and when thread state is _thread_in_native_trans
1992void JavaThread::check_safepoint_and_suspend_for_native_trans(JavaThread *thread) {
1993  assert(thread->thread_state() == _thread_in_native_trans, "wrong state");
1994
1995  JavaThread *curJT = JavaThread::current();
1996  bool do_self_suspend = thread->is_external_suspend();
1997
1998  assert(!curJT->has_last_Java_frame() || curJT->frame_anchor()->walkable(), "Unwalkable stack in native->vm transition");
1999
2000  // If JNIEnv proxies are allowed, don't self-suspend if the target
2001  // thread is not the current thread. In older versions of jdbx, jdbx
2002  // threads could call into the VM with another thread's JNIEnv so we
2003  // can be here operating on behalf of a suspended thread (4432884).
2004  if (do_self_suspend && (!AllowJNIEnvProxy || curJT == thread)) {
2005    JavaThreadState state = thread->thread_state();
2006
2007    // We mark this thread_blocked state as a suspend-equivalent so
2008    // that a caller to is_ext_suspend_completed() won't be confused.
2009    // The suspend-equivalent state is cleared by java_suspend_self().
2010    thread->set_suspend_equivalent();
2011
2012    // If the safepoint code sees the _thread_in_native_trans state, it will
2013    // wait until the thread changes to other thread state. There is no
2014    // guarantee on how soon we can obtain the SR_lock and complete the
2015    // self-suspend request. It would be a bad idea to let safepoint wait for
2016    // too long. Temporarily change the state to _thread_blocked to
2017    // let the VM thread know that this thread is ready for GC. The problem
2018    // of changing thread state is that safepoint could happen just after
2019    // java_suspend_self() returns after being resumed, and VM thread will
2020    // see the _thread_blocked state. We must check for safepoint
2021    // after restoring the state and make sure we won't leave while a safepoint
2022    // is in progress.
2023    thread->set_thread_state(_thread_blocked);
2024    thread->java_suspend_self();
2025    thread->set_thread_state(state);
2026    // Make sure new state is seen by VM thread
2027    if (os::is_MP()) {
2028      if (UseMembar) {
2029        // Force a fence between the write above and read below
2030        OrderAccess::fence();
2031      } else {
2032        // Must use this rather than serialization page in particular on Windows
2033        InterfaceSupport::serialize_memory(thread);
2034      }
2035    }
2036  }
2037
2038  if (SafepointSynchronize::do_call_back()) {
2039    // If we are safepointing, then block the caller which may not be
2040    // the same as the target thread (see above).
2041    SafepointSynchronize::block(curJT);
2042  }
2043
2044  if (thread->is_deopt_suspend()) {
2045    thread->clear_deopt_suspend();
2046    RegisterMap map(thread, false);
2047    frame f = thread->last_frame();
2048    while ( f.id() != thread->must_deopt_id() && ! f.is_first_frame()) {
2049      f = f.sender(&map);
2050    }
2051    if (f.id() == thread->must_deopt_id()) {
2052      thread->clear_must_deopt_id();
2053      // Since we know we're safe to deopt the current state is a safe state
2054      f.deoptimize(thread, true);
2055    } else {
2056      fatal("missed deoptimization!");
2057    }
2058  }
2059}
2060
2061// Slow path when the native==>VM/Java barriers detect a safepoint is in
2062// progress or when _suspend_flags is non-zero.
2063// Current thread needs to self-suspend if there is a suspend request and/or
2064// block if a safepoint is in progress.
2065// Also check for pending async exception (not including unsafe access error).
2066// Note only the native==>VM/Java barriers can call this function and when
2067// thread state is _thread_in_native_trans.
2068void JavaThread::check_special_condition_for_native_trans(JavaThread *thread) {
2069  check_safepoint_and_suspend_for_native_trans(thread);
2070
2071  if (thread->has_async_exception()) {
2072    // We are in _thread_in_native_trans state, don't handle unsafe
2073    // access error since that may block.
2074    thread->check_and_handle_async_exceptions(false);
2075  }
2076}
2077
2078// We need to guarantee the Threads_lock here, since resumes are not
2079// allowed during safepoint synchronization
2080// Can only resume from an external suspension
2081void JavaThread::java_resume() {
2082  assert_locked_or_safepoint(Threads_lock);
2083
2084  // Sanity check: thread is gone, has started exiting or the thread
2085  // was not externally suspended.
2086  if (!Threads::includes(this) || is_exiting() || !is_external_suspend()) {
2087    return;
2088  }
2089
2090  MutexLockerEx ml(SR_lock(), Mutex::_no_safepoint_check_flag);
2091
2092  clear_external_suspend();
2093
2094  if (is_ext_suspended()) {
2095    clear_ext_suspended();
2096    SR_lock()->notify_all();
2097  }
2098}
2099
2100void JavaThread::create_stack_guard_pages() {
2101  if (! os::uses_stack_guard_pages() || _stack_guard_state != stack_guard_unused) return;
2102  address low_addr = stack_base() - stack_size();
2103  size_t len = (StackYellowPages + StackRedPages) * os::vm_page_size();
2104
2105  int allocate = os::allocate_stack_guard_pages();
2106  // warning("Guarding at " PTR_FORMAT " for len " SIZE_FORMAT "\n", low_addr, len);
2107
2108  if (allocate && !os::commit_memory((char *) low_addr, len)) {
2109    warning("Attempt to allocate stack guard pages failed.");
2110    return;
2111  }
2112
2113  if (os::guard_memory((char *) low_addr, len)) {
2114    _stack_guard_state = stack_guard_enabled;
2115  } else {
2116    warning("Attempt to protect stack guard pages failed.");
2117    if (os::uncommit_memory((char *) low_addr, len)) {
2118      warning("Attempt to deallocate stack guard pages failed.");
2119    }
2120  }
2121}
2122
2123void JavaThread::remove_stack_guard_pages() {
2124  if (_stack_guard_state == stack_guard_unused) return;
2125  address low_addr = stack_base() - stack_size();
2126  size_t len = (StackYellowPages + StackRedPages) * os::vm_page_size();
2127
2128  if (os::allocate_stack_guard_pages()) {
2129    if (os::uncommit_memory((char *) low_addr, len)) {
2130      _stack_guard_state = stack_guard_unused;
2131    } else {
2132      warning("Attempt to deallocate stack guard pages failed.");
2133    }
2134  } else {
2135    if (_stack_guard_state == stack_guard_unused) return;
2136    if (os::unguard_memory((char *) low_addr, len)) {
2137      _stack_guard_state = stack_guard_unused;
2138    } else {
2139        warning("Attempt to unprotect stack guard pages failed.");
2140    }
2141  }
2142}
2143
2144void JavaThread::enable_stack_yellow_zone() {
2145  assert(_stack_guard_state != stack_guard_unused, "must be using guard pages.");
2146  assert(_stack_guard_state != stack_guard_enabled, "already enabled");
2147
2148  // The base notation is from the stacks point of view, growing downward.
2149  // We need to adjust it to work correctly with guard_memory()
2150  address base = stack_yellow_zone_base() - stack_yellow_zone_size();
2151
2152  guarantee(base < stack_base(),"Error calculating stack yellow zone");
2153  guarantee(base < os::current_stack_pointer(),"Error calculating stack yellow zone");
2154
2155  if (os::guard_memory((char *) base, stack_yellow_zone_size())) {
2156    _stack_guard_state = stack_guard_enabled;
2157  } else {
2158    warning("Attempt to guard stack yellow zone failed.");
2159  }
2160  enable_register_stack_guard();
2161}
2162
2163void JavaThread::disable_stack_yellow_zone() {
2164  assert(_stack_guard_state != stack_guard_unused, "must be using guard pages.");
2165  assert(_stack_guard_state != stack_guard_yellow_disabled, "already disabled");
2166
2167  // Simply return if called for a thread that does not use guard pages.
2168  if (_stack_guard_state == stack_guard_unused) return;
2169
2170  // The base notation is from the stacks point of view, growing downward.
2171  // We need to adjust it to work correctly with guard_memory()
2172  address base = stack_yellow_zone_base() - stack_yellow_zone_size();
2173
2174  if (os::unguard_memory((char *)base, stack_yellow_zone_size())) {
2175    _stack_guard_state = stack_guard_yellow_disabled;
2176  } else {
2177    warning("Attempt to unguard stack yellow zone failed.");
2178  }
2179  disable_register_stack_guard();
2180}
2181
2182void JavaThread::enable_stack_red_zone() {
2183  // The base notation is from the stacks point of view, growing downward.
2184  // We need to adjust it to work correctly with guard_memory()
2185  assert(_stack_guard_state != stack_guard_unused, "must be using guard pages.");
2186  address base = stack_red_zone_base() - stack_red_zone_size();
2187
2188  guarantee(base < stack_base(),"Error calculating stack red zone");
2189  guarantee(base < os::current_stack_pointer(),"Error calculating stack red zone");
2190
2191  if(!os::guard_memory((char *) base, stack_red_zone_size())) {
2192    warning("Attempt to guard stack red zone failed.");
2193  }
2194}
2195
2196void JavaThread::disable_stack_red_zone() {
2197  // The base notation is from the stacks point of view, growing downward.
2198  // We need to adjust it to work correctly with guard_memory()
2199  assert(_stack_guard_state != stack_guard_unused, "must be using guard pages.");
2200  address base = stack_red_zone_base() - stack_red_zone_size();
2201  if (!os::unguard_memory((char *)base, stack_red_zone_size())) {
2202    warning("Attempt to unguard stack red zone failed.");
2203  }
2204}
2205
2206void JavaThread::frames_do(void f(frame*, const RegisterMap* map)) {
2207  // ignore is there is no stack
2208  if (!has_last_Java_frame()) return;
2209  // traverse the stack frames. Starts from top frame.
2210  for(StackFrameStream fst(this); !fst.is_done(); fst.next()) {
2211    frame* fr = fst.current();
2212    f(fr, fst.register_map());
2213  }
2214}
2215
2216
2217#ifndef PRODUCT
2218// Deoptimization
2219// Function for testing deoptimization
2220void JavaThread::deoptimize() {
2221  // BiasedLocking needs an updated RegisterMap for the revoke monitors pass
2222  StackFrameStream fst(this, UseBiasedLocking);
2223  bool deopt = false;           // Dump stack only if a deopt actually happens.
2224  bool only_at = strlen(DeoptimizeOnlyAt) > 0;
2225  // Iterate over all frames in the thread and deoptimize
2226  for(; !fst.is_done(); fst.next()) {
2227    if(fst.current()->can_be_deoptimized()) {
2228
2229      if (only_at) {
2230        // Deoptimize only at particular bcis.  DeoptimizeOnlyAt
2231        // consists of comma or carriage return separated numbers so
2232        // search for the current bci in that string.
2233        address pc = fst.current()->pc();
2234        nmethod* nm =  (nmethod*) fst.current()->cb();
2235        ScopeDesc* sd = nm->scope_desc_at( pc);
2236        char buffer[8];
2237        jio_snprintf(buffer, sizeof(buffer), "%d", sd->bci());
2238        size_t len = strlen(buffer);
2239        const char * found = strstr(DeoptimizeOnlyAt, buffer);
2240        while (found != NULL) {
2241          if ((found[len] == ',' || found[len] == '\n' || found[len] == '\0') &&
2242              (found == DeoptimizeOnlyAt || found[-1] == ',' || found[-1] == '\n')) {
2243            // Check that the bci found is bracketed by terminators.
2244            break;
2245          }
2246          found = strstr(found + 1, buffer);
2247        }
2248        if (!found) {
2249          continue;
2250        }
2251      }
2252
2253      if (DebugDeoptimization && !deopt) {
2254        deopt = true; // One-time only print before deopt
2255        tty->print_cr("[BEFORE Deoptimization]");
2256        trace_frames();
2257        trace_stack();
2258      }
2259      Deoptimization::deoptimize(this, *fst.current(), fst.register_map());
2260    }
2261  }
2262
2263  if (DebugDeoptimization && deopt) {
2264    tty->print_cr("[AFTER Deoptimization]");
2265    trace_frames();
2266  }
2267}
2268
2269
2270// Make zombies
2271void JavaThread::make_zombies() {
2272  for(StackFrameStream fst(this); !fst.is_done(); fst.next()) {
2273    if (fst.current()->can_be_deoptimized()) {
2274      // it is a Java nmethod
2275      nmethod* nm = CodeCache::find_nmethod(fst.current()->pc());
2276      nm->make_not_entrant();
2277    }
2278  }
2279}
2280#endif // PRODUCT
2281
2282
2283void JavaThread::deoptimized_wrt_marked_nmethods() {
2284  if (!has_last_Java_frame()) return;
2285  // BiasedLocking needs an updated RegisterMap for the revoke monitors pass
2286  StackFrameStream fst(this, UseBiasedLocking);
2287  for(; !fst.is_done(); fst.next()) {
2288    if (fst.current()->should_be_deoptimized()) {
2289      Deoptimization::deoptimize(this, *fst.current(), fst.register_map());
2290    }
2291  }
2292}
2293
2294
2295// GC support
2296static void frame_gc_epilogue(frame* f, const RegisterMap* map) { f->gc_epilogue(); }
2297
2298void JavaThread::gc_epilogue() {
2299  frames_do(frame_gc_epilogue);
2300}
2301
2302
2303static void frame_gc_prologue(frame* f, const RegisterMap* map) { f->gc_prologue(); }
2304
2305void JavaThread::gc_prologue() {
2306  frames_do(frame_gc_prologue);
2307}
2308
2309
2310void JavaThread::oops_do(OopClosure* f) {
2311  // The ThreadProfiler oops_do is done from FlatProfiler::oops_do
2312  // since there may be more than one thread using each ThreadProfiler.
2313
2314  // Traverse the GCHandles
2315  Thread::oops_do(f);
2316
2317  assert( (!has_last_Java_frame() && java_call_counter() == 0) ||
2318          (has_last_Java_frame() && java_call_counter() > 0), "wrong java_sp info!");
2319
2320  if (has_last_Java_frame()) {
2321
2322    // Traverse the privileged stack
2323    if (_privileged_stack_top != NULL) {
2324      _privileged_stack_top->oops_do(f);
2325    }
2326
2327    // traverse the registered growable array
2328    if (_array_for_gc != NULL) {
2329      for (int index = 0; index < _array_for_gc->length(); index++) {
2330        f->do_oop(_array_for_gc->adr_at(index));
2331      }
2332    }
2333
2334    // Traverse the monitor chunks
2335    for (MonitorChunk* chunk = monitor_chunks(); chunk != NULL; chunk = chunk->next()) {
2336      chunk->oops_do(f);
2337    }
2338
2339    // Traverse the execution stack
2340    for(StackFrameStream fst(this); !fst.is_done(); fst.next()) {
2341      fst.current()->oops_do(f, fst.register_map());
2342    }
2343  }
2344
2345  // callee_target is never live across a gc point so NULL it here should
2346  // it still contain a methdOop.
2347
2348  set_callee_target(NULL);
2349
2350  assert(vframe_array_head() == NULL, "deopt in progress at a safepoint!");
2351  // If we have deferred set_locals there might be oops waiting to be
2352  // written
2353  GrowableArray<jvmtiDeferredLocalVariableSet*>* list = deferred_locals();
2354  if (list != NULL) {
2355    for (int i = 0; i < list->length(); i++) {
2356      list->at(i)->oops_do(f);
2357    }
2358  }
2359
2360  // Traverse instance variables at the end since the GC may be moving things
2361  // around using this function
2362  f->do_oop((oop*) &_threadObj);
2363  f->do_oop((oop*) &_vm_result);
2364  f->do_oop((oop*) &_vm_result_2);
2365  f->do_oop((oop*) &_exception_oop);
2366  f->do_oop((oop*) &_pending_async_exception);
2367
2368  if (jvmti_thread_state() != NULL) {
2369    jvmti_thread_state()->oops_do(f);
2370  }
2371}
2372
2373void JavaThread::nmethods_do() {
2374  // Traverse the GCHandles
2375  Thread::nmethods_do();
2376
2377  assert( (!has_last_Java_frame() && java_call_counter() == 0) ||
2378          (has_last_Java_frame() && java_call_counter() > 0), "wrong java_sp info!");
2379
2380  if (has_last_Java_frame()) {
2381    // Traverse the execution stack
2382    for(StackFrameStream fst(this); !fst.is_done(); fst.next()) {
2383      fst.current()->nmethods_do();
2384    }
2385  }
2386}
2387
2388// Printing
2389const char* _get_thread_state_name(JavaThreadState _thread_state) {
2390  switch (_thread_state) {
2391  case _thread_uninitialized:     return "_thread_uninitialized";
2392  case _thread_new:               return "_thread_new";
2393  case _thread_new_trans:         return "_thread_new_trans";
2394  case _thread_in_native:         return "_thread_in_native";
2395  case _thread_in_native_trans:   return "_thread_in_native_trans";
2396  case _thread_in_vm:             return "_thread_in_vm";
2397  case _thread_in_vm_trans:       return "_thread_in_vm_trans";
2398  case _thread_in_Java:           return "_thread_in_Java";
2399  case _thread_in_Java_trans:     return "_thread_in_Java_trans";
2400  case _thread_blocked:           return "_thread_blocked";
2401  case _thread_blocked_trans:     return "_thread_blocked_trans";
2402  default:                        return "unknown thread state";
2403  }
2404}
2405
2406#ifndef PRODUCT
2407void JavaThread::print_thread_state_on(outputStream *st) const {
2408  st->print_cr("   JavaThread state: %s", _get_thread_state_name(_thread_state));
2409};
2410void JavaThread::print_thread_state() const {
2411  print_thread_state_on(tty);
2412};
2413#endif // PRODUCT
2414
2415// Called by Threads::print() for VM_PrintThreads operation
2416void JavaThread::print_on(outputStream *st) const {
2417  st->print("\"%s\" ", get_thread_name());
2418  oop thread_oop = threadObj();
2419  if (thread_oop != NULL && java_lang_Thread::is_daemon(thread_oop))  st->print("daemon ");
2420  Thread::print_on(st);
2421  // print guess for valid stack memory region (assume 4K pages); helps lock debugging
2422  st->print_cr("[" INTPTR_FORMAT ".." INTPTR_FORMAT "]", (intptr_t)last_Java_sp() & ~right_n_bits(12), highest_lock());
2423  if (thread_oop != NULL && JDK_Version::is_gte_jdk15x_version()) {
2424    st->print_cr("   java.lang.Thread.State: %s", java_lang_Thread::thread_status_name(thread_oop));
2425  }
2426#ifndef PRODUCT
2427  print_thread_state_on(st);
2428  _safepoint_state->print_on(st);
2429#endif // PRODUCT
2430}
2431
2432// Called by fatal error handler. The difference between this and
2433// JavaThread::print() is that we can't grab lock or allocate memory.
2434void JavaThread::print_on_error(outputStream* st, char *buf, int buflen) const {
2435  st->print("JavaThread \"%s\"",  get_thread_name_string(buf, buflen));
2436  oop thread_obj = threadObj();
2437  if (thread_obj != NULL) {
2438     if (java_lang_Thread::is_daemon(thread_obj)) st->print(" daemon");
2439  }
2440  st->print(" [");
2441  st->print("%s", _get_thread_state_name(_thread_state));
2442  if (osthread()) {
2443    st->print(", id=%d", osthread()->thread_id());
2444  }
2445  st->print(", stack(" PTR_FORMAT "," PTR_FORMAT ")",
2446            _stack_base - _stack_size, _stack_base);
2447  st->print("]");
2448  return;
2449}
2450
2451// Verification
2452
2453static void frame_verify(frame* f, const RegisterMap *map) { f->verify(map); }
2454
2455void JavaThread::verify() {
2456  // Verify oops in the thread.
2457  oops_do(&VerifyOopClosure::verify_oop);
2458
2459  // Verify the stack frames.
2460  frames_do(frame_verify);
2461}
2462
2463// CR 6300358 (sub-CR 2137150)
2464// Most callers of this method assume that it can't return NULL but a
2465// thread may not have a name whilst it is in the process of attaching to
2466// the VM - see CR 6412693, and there are places where a JavaThread can be
2467// seen prior to having it's threadObj set (eg JNI attaching threads and
2468// if vm exit occurs during initialization). These cases can all be accounted
2469// for such that this method never returns NULL.
2470const char* JavaThread::get_thread_name() const {
2471#ifdef ASSERT
2472  // early safepoints can hit while current thread does not yet have TLS
2473  if (!SafepointSynchronize::is_at_safepoint()) {
2474    Thread *cur = Thread::current();
2475    if (!(cur->is_Java_thread() && cur == this)) {
2476      // Current JavaThreads are allowed to get their own name without
2477      // the Threads_lock.
2478      assert_locked_or_safepoint(Threads_lock);
2479    }
2480  }
2481#endif // ASSERT
2482    return get_thread_name_string();
2483}
2484
2485// Returns a non-NULL representation of this thread's name, or a suitable
2486// descriptive string if there is no set name
2487const char* JavaThread::get_thread_name_string(char* buf, int buflen) const {
2488  const char* name_str;
2489  oop thread_obj = threadObj();
2490  if (thread_obj != NULL) {
2491    typeArrayOop name = java_lang_Thread::name(thread_obj);
2492    if (name != NULL) {
2493      if (buf == NULL) {
2494        name_str = UNICODE::as_utf8((jchar*) name->base(T_CHAR), name->length());
2495      }
2496      else {
2497        name_str = UNICODE::as_utf8((jchar*) name->base(T_CHAR), name->length(), buf, buflen);
2498      }
2499    }
2500    else if (is_attaching()) { // workaround for 6412693 - see 6404306
2501      name_str = "<no-name - thread is attaching>";
2502    }
2503    else {
2504      name_str = Thread::name();
2505    }
2506  }
2507  else {
2508    name_str = Thread::name();
2509  }
2510  assert(name_str != NULL, "unexpected NULL thread name");
2511  return name_str;
2512}
2513
2514
2515const char* JavaThread::get_threadgroup_name() const {
2516  debug_only(if (JavaThread::current() != this) assert_locked_or_safepoint(Threads_lock);)
2517  oop thread_obj = threadObj();
2518  if (thread_obj != NULL) {
2519    oop thread_group = java_lang_Thread::threadGroup(thread_obj);
2520    if (thread_group != NULL) {
2521      typeArrayOop name = java_lang_ThreadGroup::name(thread_group);
2522      // ThreadGroup.name can be null
2523      if (name != NULL) {
2524        const char* str = UNICODE::as_utf8((jchar*) name->base(T_CHAR), name->length());
2525        return str;
2526      }
2527    }
2528  }
2529  return NULL;
2530}
2531
2532const char* JavaThread::get_parent_name() const {
2533  debug_only(if (JavaThread::current() != this) assert_locked_or_safepoint(Threads_lock);)
2534  oop thread_obj = threadObj();
2535  if (thread_obj != NULL) {
2536    oop thread_group = java_lang_Thread::threadGroup(thread_obj);
2537    if (thread_group != NULL) {
2538      oop parent = java_lang_ThreadGroup::parent(thread_group);
2539      if (parent != NULL) {
2540        typeArrayOop name = java_lang_ThreadGroup::name(parent);
2541        // ThreadGroup.name can be null
2542        if (name != NULL) {
2543          const char* str = UNICODE::as_utf8((jchar*) name->base(T_CHAR), name->length());
2544          return str;
2545        }
2546      }
2547    }
2548  }
2549  return NULL;
2550}
2551
2552ThreadPriority JavaThread::java_priority() const {
2553  oop thr_oop = threadObj();
2554  if (thr_oop == NULL) return NormPriority; // Bootstrapping
2555  ThreadPriority priority = java_lang_Thread::priority(thr_oop);
2556  assert(MinPriority <= priority && priority <= MaxPriority, "sanity check");
2557  return priority;
2558}
2559
2560void JavaThread::prepare(jobject jni_thread, ThreadPriority prio) {
2561
2562  assert(Threads_lock->owner() == Thread::current(), "must have threads lock");
2563  // Link Java Thread object <-> C++ Thread
2564
2565  // Get the C++ thread object (an oop) from the JNI handle (a jthread)
2566  // and put it into a new Handle.  The Handle "thread_oop" can then
2567  // be used to pass the C++ thread object to other methods.
2568
2569  // Set the Java level thread object (jthread) field of the
2570  // new thread (a JavaThread *) to C++ thread object using the
2571  // "thread_oop" handle.
2572
2573  // Set the thread field (a JavaThread *) of the
2574  // oop representing the java_lang_Thread to the new thread (a JavaThread *).
2575
2576  Handle thread_oop(Thread::current(),
2577                    JNIHandles::resolve_non_null(jni_thread));
2578  assert(instanceKlass::cast(thread_oop->klass())->is_linked(),
2579    "must be initialized");
2580  set_threadObj(thread_oop());
2581  java_lang_Thread::set_thread(thread_oop(), this);
2582
2583  if (prio == NoPriority) {
2584    prio = java_lang_Thread::priority(thread_oop());
2585    assert(prio != NoPriority, "A valid priority should be present");
2586  }
2587
2588  // Push the Java priority down to the native thread; needs Threads_lock
2589  Thread::set_priority(this, prio);
2590
2591  // Add the new thread to the Threads list and set it in motion.
2592  // We must have threads lock in order to call Threads::add.
2593  // It is crucial that we do not block before the thread is
2594  // added to the Threads list for if a GC happens, then the java_thread oop
2595  // will not be visited by GC.
2596  Threads::add(this);
2597}
2598
2599oop JavaThread::current_park_blocker() {
2600  // Support for JSR-166 locks
2601  oop thread_oop = threadObj();
2602  if (thread_oop != NULL && JDK_Version::supports_thread_park_blocker()) {
2603    return java_lang_Thread::park_blocker(thread_oop);
2604  }
2605  return NULL;
2606}
2607
2608
2609void JavaThread::print_stack_on(outputStream* st) {
2610  if (!has_last_Java_frame()) return;
2611  ResourceMark rm;
2612  HandleMark   hm;
2613
2614  RegisterMap reg_map(this);
2615  vframe* start_vf = last_java_vframe(&reg_map);
2616  int count = 0;
2617  for (vframe* f = start_vf; f; f = f->sender() ) {
2618    if (f->is_java_frame()) {
2619      javaVFrame* jvf = javaVFrame::cast(f);
2620      java_lang_Throwable::print_stack_element(st, jvf->method(), jvf->bci());
2621
2622      // Print out lock information
2623      if (JavaMonitorsInStackTrace) {
2624        jvf->print_lock_info_on(st, count);
2625      }
2626    } else {
2627      // Ignore non-Java frames
2628    }
2629
2630    // Bail-out case for too deep stacks
2631    count++;
2632    if (MaxJavaStackTraceDepth == count) return;
2633  }
2634}
2635
2636
2637// JVMTI PopFrame support
2638void JavaThread::popframe_preserve_args(ByteSize size_in_bytes, void* start) {
2639  assert(_popframe_preserved_args == NULL, "should not wipe out old PopFrame preserved arguments");
2640  if (in_bytes(size_in_bytes) != 0) {
2641    _popframe_preserved_args = NEW_C_HEAP_ARRAY(char, in_bytes(size_in_bytes));
2642    _popframe_preserved_args_size = in_bytes(size_in_bytes);
2643    Copy::conjoint_bytes(start, _popframe_preserved_args, _popframe_preserved_args_size);
2644  }
2645}
2646
2647void* JavaThread::popframe_preserved_args() {
2648  return _popframe_preserved_args;
2649}
2650
2651ByteSize JavaThread::popframe_preserved_args_size() {
2652  return in_ByteSize(_popframe_preserved_args_size);
2653}
2654
2655WordSize JavaThread::popframe_preserved_args_size_in_words() {
2656  int sz = in_bytes(popframe_preserved_args_size());
2657  assert(sz % wordSize == 0, "argument size must be multiple of wordSize");
2658  return in_WordSize(sz / wordSize);
2659}
2660
2661void JavaThread::popframe_free_preserved_args() {
2662  assert(_popframe_preserved_args != NULL, "should not free PopFrame preserved arguments twice");
2663  FREE_C_HEAP_ARRAY(char, (char*) _popframe_preserved_args);
2664  _popframe_preserved_args = NULL;
2665  _popframe_preserved_args_size = 0;
2666}
2667
2668#ifndef PRODUCT
2669
2670void JavaThread::trace_frames() {
2671  tty->print_cr("[Describe stack]");
2672  int frame_no = 1;
2673  for(StackFrameStream fst(this); !fst.is_done(); fst.next()) {
2674    tty->print("  %d. ", frame_no++);
2675    fst.current()->print_value_on(tty,this);
2676    tty->cr();
2677  }
2678}
2679
2680
2681void JavaThread::trace_stack_from(vframe* start_vf) {
2682  ResourceMark rm;
2683  int vframe_no = 1;
2684  for (vframe* f = start_vf; f; f = f->sender() ) {
2685    if (f->is_java_frame()) {
2686      javaVFrame::cast(f)->print_activation(vframe_no++);
2687    } else {
2688      f->print();
2689    }
2690    if (vframe_no > StackPrintLimit) {
2691      tty->print_cr("...<more frames>...");
2692      return;
2693    }
2694  }
2695}
2696
2697
2698void JavaThread::trace_stack() {
2699  if (!has_last_Java_frame()) return;
2700  ResourceMark rm;
2701  HandleMark   hm;
2702  RegisterMap reg_map(this);
2703  trace_stack_from(last_java_vframe(&reg_map));
2704}
2705
2706
2707#endif // PRODUCT
2708
2709
2710javaVFrame* JavaThread::last_java_vframe(RegisterMap *reg_map) {
2711  assert(reg_map != NULL, "a map must be given");
2712  frame f = last_frame();
2713  for (vframe* vf = vframe::new_vframe(&f, reg_map, this); vf; vf = vf->sender() ) {
2714    if (vf->is_java_frame()) return javaVFrame::cast(vf);
2715  }
2716  return NULL;
2717}
2718
2719
2720klassOop JavaThread::security_get_caller_class(int depth) {
2721  vframeStream vfst(this);
2722  vfst.security_get_caller_frame(depth);
2723  if (!vfst.at_end()) {
2724    return vfst.method()->method_holder();
2725  }
2726  return NULL;
2727}
2728
2729static void compiler_thread_entry(JavaThread* thread, TRAPS) {
2730  assert(thread->is_Compiler_thread(), "must be compiler thread");
2731  CompileBroker::compiler_thread_loop();
2732}
2733
2734// Create a CompilerThread
2735CompilerThread::CompilerThread(CompileQueue* queue, CompilerCounters* counters)
2736: JavaThread(&compiler_thread_entry) {
2737  _env   = NULL;
2738  _log   = NULL;
2739  _task  = NULL;
2740  _queue = queue;
2741  _counters = counters;
2742
2743#ifndef PRODUCT
2744  _ideal_graph_printer = NULL;
2745#endif
2746}
2747
2748
2749// ======= Threads ========
2750
2751// The Threads class links together all active threads, and provides
2752// operations over all threads.  It is protected by its own Mutex
2753// lock, which is also used in other contexts to protect thread
2754// operations from having the thread being operated on from exiting
2755// and going away unexpectedly (e.g., safepoint synchronization)
2756
2757JavaThread* Threads::_thread_list = NULL;
2758int         Threads::_number_of_threads = 0;
2759int         Threads::_number_of_non_daemon_threads = 0;
2760int         Threads::_return_code = 0;
2761size_t      JavaThread::_stack_size_at_create = 0;
2762
2763// All JavaThreads
2764#define ALL_JAVA_THREADS(X) for (JavaThread* X = _thread_list; X; X = X->next())
2765
2766void os_stream();
2767
2768// All JavaThreads + all non-JavaThreads (i.e., every thread in the system)
2769void Threads::threads_do(ThreadClosure* tc) {
2770  assert_locked_or_safepoint(Threads_lock);
2771  // ALL_JAVA_THREADS iterates through all JavaThreads
2772  ALL_JAVA_THREADS(p) {
2773    tc->do_thread(p);
2774  }
2775  // Someday we could have a table or list of all non-JavaThreads.
2776  // For now, just manually iterate through them.
2777  tc->do_thread(VMThread::vm_thread());
2778  Universe::heap()->gc_threads_do(tc);
2779  tc->do_thread(WatcherThread::watcher_thread());
2780  // If CompilerThreads ever become non-JavaThreads, add them here
2781}
2782
2783jint Threads::create_vm(JavaVMInitArgs* args, bool* canTryAgain) {
2784
2785  // Check version
2786  if (!is_supported_jni_version(args->version)) return JNI_EVERSION;
2787
2788  // Initialize the output stream module
2789  ostream_init();
2790
2791  // Process java launcher properties.
2792  Arguments::process_sun_java_launcher_properties(args);
2793
2794  // Initialize the os module before using TLS
2795  os::init();
2796
2797  // Initialize system properties.
2798  Arguments::init_system_properties();
2799
2800  // Parse arguments
2801  jint parse_result = Arguments::parse(args);
2802  if (parse_result != JNI_OK) return parse_result;
2803
2804  if (PauseAtStartup) {
2805    os::pause();
2806  }
2807
2808  HS_DTRACE_PROBE(hotspot, vm__init__begin);
2809
2810  // Record VM creation timing statistics
2811  TraceVmCreationTime create_vm_timer;
2812  create_vm_timer.start();
2813
2814  // Timing (must come after argument parsing)
2815  TraceTime timer("Create VM", TraceStartupTime);
2816
2817  // Initialize the os module after parsing the args
2818  jint os_init_2_result = os::init_2();
2819  if (os_init_2_result != JNI_OK) return os_init_2_result;
2820
2821  // Initialize output stream logging
2822  ostream_init_log();
2823
2824  // Convert -Xrun to -agentlib: if there is no JVM_OnLoad
2825  // Must be before create_vm_init_agents()
2826  if (Arguments::init_libraries_at_startup()) {
2827    convert_vm_init_libraries_to_agents();
2828  }
2829
2830  // Launch -agentlib/-agentpath and converted -Xrun agents
2831  if (Arguments::init_agents_at_startup()) {
2832    create_vm_init_agents();
2833  }
2834
2835  // Initialize Threads state
2836  _thread_list = NULL;
2837  _number_of_threads = 0;
2838  _number_of_non_daemon_threads = 0;
2839
2840  // Initialize TLS
2841  ThreadLocalStorage::init();
2842
2843  // Initialize global data structures and create system classes in heap
2844  vm_init_globals();
2845
2846  // Attach the main thread to this os thread
2847  JavaThread* main_thread = new JavaThread();
2848  main_thread->set_thread_state(_thread_in_vm);
2849  // must do this before set_active_handles and initialize_thread_local_storage
2850  // Note: on solaris initialize_thread_local_storage() will (indirectly)
2851  // change the stack size recorded here to one based on the java thread
2852  // stacksize. This adjusted size is what is used to figure the placement
2853  // of the guard pages.
2854  main_thread->record_stack_base_and_size();
2855  main_thread->initialize_thread_local_storage();
2856
2857  main_thread->set_active_handles(JNIHandleBlock::allocate_block());
2858
2859  if (!main_thread->set_as_starting_thread()) {
2860    vm_shutdown_during_initialization(
2861      "Failed necessary internal allocation. Out of swap space");
2862    delete main_thread;
2863    *canTryAgain = false; // don't let caller call JNI_CreateJavaVM again
2864    return JNI_ENOMEM;
2865  }
2866
2867  // Enable guard page *after* os::create_main_thread(), otherwise it would
2868  // crash Linux VM, see notes in os_linux.cpp.
2869  main_thread->create_stack_guard_pages();
2870
2871  // Initialize Java-Leve synchronization subsystem
2872  ObjectSynchronizer::Initialize() ;
2873
2874  // Initialize global modules
2875  jint status = init_globals();
2876  if (status != JNI_OK) {
2877    delete main_thread;
2878    *canTryAgain = false; // don't let caller call JNI_CreateJavaVM again
2879    return status;
2880  }
2881
2882  HandleMark hm;
2883
2884  { MutexLocker mu(Threads_lock);
2885    Threads::add(main_thread);
2886  }
2887
2888  // Any JVMTI raw monitors entered in onload will transition into
2889  // real raw monitor. VM is setup enough here for raw monitor enter.
2890  JvmtiExport::transition_pending_onload_raw_monitors();
2891
2892  if (VerifyBeforeGC &&
2893      Universe::heap()->total_collections() >= VerifyGCStartAt) {
2894    Universe::heap()->prepare_for_verify();
2895    Universe::verify();   // make sure we're starting with a clean slate
2896  }
2897
2898  // Create the VMThread
2899  { TraceTime timer("Start VMThread", TraceStartupTime);
2900    VMThread::create();
2901    Thread* vmthread = VMThread::vm_thread();
2902
2903    if (!os::create_thread(vmthread, os::vm_thread))
2904      vm_exit_during_initialization("Cannot create VM thread. Out of system resources.");
2905
2906    // Wait for the VM thread to become ready, and VMThread::run to initialize
2907    // Monitors can have spurious returns, must always check another state flag
2908    {
2909      MutexLocker ml(Notify_lock);
2910      os::start_thread(vmthread);
2911      while (vmthread->active_handles() == NULL) {
2912        Notify_lock->wait();
2913      }
2914    }
2915  }
2916
2917  assert (Universe::is_fully_initialized(), "not initialized");
2918  EXCEPTION_MARK;
2919
2920  // At this point, the Universe is initialized, but we have not executed
2921  // any byte code.  Now is a good time (the only time) to dump out the
2922  // internal state of the JVM for sharing.
2923
2924  if (DumpSharedSpaces) {
2925    Universe::heap()->preload_and_dump(CHECK_0);
2926    ShouldNotReachHere();
2927  }
2928
2929  // Always call even when there are not JVMTI environments yet, since environments
2930  // may be attached late and JVMTI must track phases of VM execution
2931  JvmtiExport::enter_start_phase();
2932
2933  // Notify JVMTI agents that VM has started (JNI is up) - nop if no agents.
2934  JvmtiExport::post_vm_start();
2935
2936  {
2937    TraceTime timer("Initialize java.lang classes", TraceStartupTime);
2938
2939    if (EagerXrunInit && Arguments::init_libraries_at_startup()) {
2940      create_vm_init_libraries();
2941    }
2942
2943    if (InitializeJavaLangString) {
2944      initialize_class(vmSymbolHandles::java_lang_String(), CHECK_0);
2945    } else {
2946      warning("java.lang.String not initialized");
2947    }
2948
2949    if (AggressiveOpts) {
2950      // Forcibly initialize java/util/HashMap and mutate the private
2951      // static final "frontCacheEnabled" field before we start creating instances
2952#ifdef ASSERT
2953      klassOop tmp_k = SystemDictionary::find(vmSymbolHandles::java_util_HashMap(), Handle(), Handle(), CHECK_0);
2954      assert(tmp_k == NULL, "java/util/HashMap should not be loaded yet");
2955#endif
2956      klassOop k_o = SystemDictionary::resolve_or_null(vmSymbolHandles::java_util_HashMap(), Handle(), Handle(), CHECK_0);
2957      KlassHandle k = KlassHandle(THREAD, k_o);
2958      guarantee(k.not_null(), "Must find java/util/HashMap");
2959      instanceKlassHandle ik = instanceKlassHandle(THREAD, k());
2960      ik->initialize(CHECK_0);
2961      fieldDescriptor fd;
2962      // Possible we might not find this field; if so, don't break
2963      if (ik->find_local_field(vmSymbols::frontCacheEnabled_name(), vmSymbols::bool_signature(), &fd)) {
2964        k()->bool_field_put(fd.offset(), true);
2965      }
2966    }
2967
2968    // Initialize java_lang.System (needed before creating the thread)
2969    if (InitializeJavaLangSystem) {
2970      initialize_class(vmSymbolHandles::java_lang_System(), CHECK_0);
2971      initialize_class(vmSymbolHandles::java_lang_ThreadGroup(), CHECK_0);
2972      Handle thread_group = create_initial_thread_group(CHECK_0);
2973      Universe::set_main_thread_group(thread_group());
2974      initialize_class(vmSymbolHandles::java_lang_Thread(), CHECK_0);
2975      oop thread_object = create_initial_thread(thread_group, main_thread, CHECK_0);
2976      main_thread->set_threadObj(thread_object);
2977      // Set thread status to running since main thread has
2978      // been started and running.
2979      java_lang_Thread::set_thread_status(thread_object,
2980                                          java_lang_Thread::RUNNABLE);
2981
2982      // The VM preresolve methods to these classes. Make sure that get initialized
2983      initialize_class(vmSymbolHandles::java_lang_reflect_Method(), CHECK_0);
2984      initialize_class(vmSymbolHandles::java_lang_ref_Finalizer(),  CHECK_0);
2985      // The VM creates & returns objects of this class. Make sure it's initialized.
2986      initialize_class(vmSymbolHandles::java_lang_Class(), CHECK_0);
2987      call_initializeSystemClass(CHECK_0);
2988    } else {
2989      warning("java.lang.System not initialized");
2990    }
2991
2992    // an instance of OutOfMemory exception has been allocated earlier
2993    if (InitializeJavaLangExceptionsErrors) {
2994      initialize_class(vmSymbolHandles::java_lang_OutOfMemoryError(), CHECK_0);
2995      initialize_class(vmSymbolHandles::java_lang_NullPointerException(), CHECK_0);
2996      initialize_class(vmSymbolHandles::java_lang_ClassCastException(), CHECK_0);
2997      initialize_class(vmSymbolHandles::java_lang_ArrayStoreException(), CHECK_0);
2998      initialize_class(vmSymbolHandles::java_lang_ArithmeticException(), CHECK_0);
2999      initialize_class(vmSymbolHandles::java_lang_StackOverflowError(), CHECK_0);
3000      initialize_class(vmSymbolHandles::java_lang_IllegalMonitorStateException(), CHECK_0);
3001    } else {
3002      warning("java.lang.OutOfMemoryError has not been initialized");
3003      warning("java.lang.NullPointerException has not been initialized");
3004      warning("java.lang.ClassCastException has not been initialized");
3005      warning("java.lang.ArrayStoreException has not been initialized");
3006      warning("java.lang.ArithmeticException has not been initialized");
3007      warning("java.lang.StackOverflowError has not been initialized");
3008    }
3009  }
3010
3011  // See        : bugid 4211085.
3012  // Background : the static initializer of java.lang.Compiler tries to read
3013  //              property"java.compiler" and read & write property "java.vm.info".
3014  //              When a security manager is installed through the command line
3015  //              option "-Djava.security.manager", the above properties are not
3016  //              readable and the static initializer for java.lang.Compiler fails
3017  //              resulting in a NoClassDefFoundError.  This can happen in any
3018  //              user code which calls methods in java.lang.Compiler.
3019  // Hack :       the hack is to pre-load and initialize this class, so that only
3020  //              system domains are on the stack when the properties are read.
3021  //              Currently even the AWT code has calls to methods in java.lang.Compiler.
3022  //              On the classic VM, java.lang.Compiler is loaded very early to load the JIT.
3023  // Future Fix : the best fix is to grant everyone permissions to read "java.compiler" and
3024  //              read and write"java.vm.info" in the default policy file. See bugid 4211383
3025  //              Once that is done, we should remove this hack.
3026  initialize_class(vmSymbolHandles::java_lang_Compiler(), CHECK_0);
3027
3028  // More hackery - the static initializer of java.lang.Compiler adds the string "nojit" to
3029  // the java.vm.info property if no jit gets loaded through java.lang.Compiler (the hotspot
3030  // compiler does not get loaded through java.lang.Compiler).  "java -version" with the
3031  // hotspot vm says "nojit" all the time which is confusing.  So, we reset it here.
3032  // This should also be taken out as soon as 4211383 gets fixed.
3033  reset_vm_info_property(CHECK_0);
3034
3035  quicken_jni_functions();
3036
3037  // Set flag that basic initialization has completed. Used by exceptions and various
3038  // debug stuff, that does not work until all basic classes have been initialized.
3039  set_init_completed();
3040
3041  HS_DTRACE_PROBE(hotspot, vm__init__end);
3042
3043  // record VM initialization completion time
3044  Management::record_vm_init_completed();
3045
3046  // Compute system loader. Note that this has to occur after set_init_completed, since
3047  // valid exceptions may be thrown in the process.
3048  // Note that we do not use CHECK_0 here since we are inside an EXCEPTION_MARK and
3049  // set_init_completed has just been called, causing exceptions not to be shortcut
3050  // anymore. We call vm_exit_during_initialization directly instead.
3051  SystemDictionary::compute_java_system_loader(THREAD);
3052  if (HAS_PENDING_EXCEPTION) {
3053    vm_exit_during_initialization(Handle(THREAD, PENDING_EXCEPTION));
3054  }
3055
3056#ifndef SERIALGC
3057  // Support for ConcurrentMarkSweep. This should be cleaned up
3058  // and better encapsulated. The ugly nested if test would go away
3059  // once things are properly refactored. XXX YSR
3060  if (UseConcMarkSweepGC || UseG1GC) {
3061    if (UseConcMarkSweepGC) {
3062      ConcurrentMarkSweepThread::makeSurrogateLockerThread(THREAD);
3063    } else {
3064      ConcurrentMarkThread::makeSurrogateLockerThread(THREAD);
3065    }
3066    if (HAS_PENDING_EXCEPTION) {
3067      vm_exit_during_initialization(Handle(THREAD, PENDING_EXCEPTION));
3068    }
3069  }
3070#endif // SERIALGC
3071
3072  // Always call even when there are not JVMTI environments yet, since environments
3073  // may be attached late and JVMTI must track phases of VM execution
3074  JvmtiExport::enter_live_phase();
3075
3076  // Signal Dispatcher needs to be started before VMInit event is posted
3077  os::signal_init();
3078
3079  // Start Attach Listener if +StartAttachListener or it can't be started lazily
3080  if (!DisableAttachMechanism) {
3081    if (StartAttachListener || AttachListener::init_at_startup()) {
3082      AttachListener::init();
3083    }
3084  }
3085
3086  // Launch -Xrun agents
3087  // Must be done in the JVMTI live phase so that for backward compatibility the JDWP
3088  // back-end can launch with -Xdebug -Xrunjdwp.
3089  if (!EagerXrunInit && Arguments::init_libraries_at_startup()) {
3090    create_vm_init_libraries();
3091  }
3092
3093  // Notify JVMTI agents that VM initialization is complete - nop if no agents.
3094  JvmtiExport::post_vm_initialized();
3095
3096  Chunk::start_chunk_pool_cleaner_task();
3097
3098  // initialize compiler(s)
3099  CompileBroker::compilation_init();
3100
3101  Management::initialize(THREAD);
3102  if (HAS_PENDING_EXCEPTION) {
3103    // management agent fails to start possibly due to
3104    // configuration problem and is responsible for printing
3105    // stack trace if appropriate. Simply exit VM.
3106    vm_exit(1);
3107  }
3108
3109  if (Arguments::has_profile())       FlatProfiler::engage(main_thread, true);
3110  if (Arguments::has_alloc_profile()) AllocationProfiler::engage();
3111  if (MemProfiling)                   MemProfiler::engage();
3112  StatSampler::engage();
3113  if (CheckJNICalls)                  JniPeriodicChecker::engage();
3114
3115  BiasedLocking::init();
3116
3117
3118  // Start up the WatcherThread if there are any periodic tasks
3119  // NOTE:  All PeriodicTasks should be registered by now. If they
3120  //   aren't, late joiners might appear to start slowly (we might
3121  //   take a while to process their first tick).
3122  if (PeriodicTask::num_tasks() > 0) {
3123    WatcherThread::start();
3124  }
3125
3126  create_vm_timer.end();
3127  return JNI_OK;
3128}
3129
3130// type for the Agent_OnLoad and JVM_OnLoad entry points
3131extern "C" {
3132  typedef jint (JNICALL *OnLoadEntry_t)(JavaVM *, char *, void *);
3133}
3134// Find a command line agent library and return its entry point for
3135//         -agentlib:  -agentpath:   -Xrun
3136// num_symbol_entries must be passed-in since only the caller knows the number of symbols in the array.
3137static OnLoadEntry_t lookup_on_load(AgentLibrary* agent, const char *on_load_symbols[], size_t num_symbol_entries) {
3138  OnLoadEntry_t on_load_entry = NULL;
3139  void *library = agent->os_lib();  // check if we have looked it up before
3140
3141  if (library == NULL) {
3142    char buffer[JVM_MAXPATHLEN];
3143    char ebuf[1024];
3144    const char *name = agent->name();
3145
3146    if (agent->is_absolute_path()) {
3147      library = hpi::dll_load(name, ebuf, sizeof ebuf);
3148      if (library == NULL) {
3149        // If we can't find the agent, exit.
3150        vm_exit_during_initialization("Could not find agent library in absolute path", name);
3151      }
3152    } else {
3153      // Try to load the agent from the standard dll directory
3154      hpi::dll_build_name(buffer, sizeof(buffer), Arguments::get_dll_dir(), name);
3155      library = hpi::dll_load(buffer, ebuf, sizeof ebuf);
3156#ifdef KERNEL
3157      // Download instrument dll
3158      if (library == NULL && strcmp(name, "instrument") == 0) {
3159        char *props = Arguments::get_kernel_properties();
3160        char *home  = Arguments::get_java_home();
3161        const char *fmt   = "%s/bin/java %s -Dkernel.background.download=false"
3162                      " sun.jkernel.DownloadManager -download client_jvm";
3163        int length = strlen(props) + strlen(home) + strlen(fmt) + 1;
3164        char *cmd = AllocateHeap(length);
3165        jio_snprintf(cmd, length, fmt, home, props);
3166        int status = os::fork_and_exec(cmd);
3167        FreeHeap(props);
3168        FreeHeap(cmd);
3169        if (status == -1) {
3170          warning(cmd);
3171          vm_exit_during_initialization("fork_and_exec failed: %s",
3172                                         strerror(errno));
3173        }
3174        // when this comes back the instrument.dll should be where it belongs.
3175        library = hpi::dll_load(buffer, ebuf, sizeof ebuf);
3176      }
3177#endif // KERNEL
3178      if (library == NULL) { // Try the local directory
3179        char ns[1] = {0};
3180        hpi::dll_build_name(buffer, sizeof(buffer), ns, name);
3181        library = hpi::dll_load(buffer, ebuf, sizeof ebuf);
3182        if (library == NULL) {
3183          // If we can't find the agent, exit.
3184          vm_exit_during_initialization("Could not find agent library on the library path or in the local directory", name);
3185        }
3186      }
3187    }
3188    agent->set_os_lib(library);
3189  }
3190
3191  // Find the OnLoad function.
3192  for (size_t symbol_index = 0; symbol_index < num_symbol_entries; symbol_index++) {
3193    on_load_entry = CAST_TO_FN_PTR(OnLoadEntry_t, hpi::dll_lookup(library, on_load_symbols[symbol_index]));
3194    if (on_load_entry != NULL) break;
3195  }
3196  return on_load_entry;
3197}
3198
3199// Find the JVM_OnLoad entry point
3200static OnLoadEntry_t lookup_jvm_on_load(AgentLibrary* agent) {
3201  const char *on_load_symbols[] = JVM_ONLOAD_SYMBOLS;
3202  return lookup_on_load(agent, on_load_symbols, sizeof(on_load_symbols) / sizeof(char*));
3203}
3204
3205// Find the Agent_OnLoad entry point
3206static OnLoadEntry_t lookup_agent_on_load(AgentLibrary* agent) {
3207  const char *on_load_symbols[] = AGENT_ONLOAD_SYMBOLS;
3208  return lookup_on_load(agent, on_load_symbols, sizeof(on_load_symbols) / sizeof(char*));
3209}
3210
3211// For backwards compatibility with -Xrun
3212// Convert libraries with no JVM_OnLoad, but which have Agent_OnLoad to be
3213// treated like -agentpath:
3214// Must be called before agent libraries are created
3215void Threads::convert_vm_init_libraries_to_agents() {
3216  AgentLibrary* agent;
3217  AgentLibrary* next;
3218
3219  for (agent = Arguments::libraries(); agent != NULL; agent = next) {
3220    next = agent->next();  // cache the next agent now as this agent may get moved off this list
3221    OnLoadEntry_t on_load_entry = lookup_jvm_on_load(agent);
3222
3223    // If there is an JVM_OnLoad function it will get called later,
3224    // otherwise see if there is an Agent_OnLoad
3225    if (on_load_entry == NULL) {
3226      on_load_entry = lookup_agent_on_load(agent);
3227      if (on_load_entry != NULL) {
3228        // switch it to the agent list -- so that Agent_OnLoad will be called,
3229        // JVM_OnLoad won't be attempted and Agent_OnUnload will
3230        Arguments::convert_library_to_agent(agent);
3231      } else {
3232        vm_exit_during_initialization("Could not find JVM_OnLoad or Agent_OnLoad function in the library", agent->name());
3233      }
3234    }
3235  }
3236}
3237
3238// Create agents for -agentlib:  -agentpath:  and converted -Xrun
3239// Invokes Agent_OnLoad
3240// Called very early -- before JavaThreads exist
3241void Threads::create_vm_init_agents() {
3242  extern struct JavaVM_ main_vm;
3243  AgentLibrary* agent;
3244
3245  JvmtiExport::enter_onload_phase();
3246  for (agent = Arguments::agents(); agent != NULL; agent = agent->next()) {
3247    OnLoadEntry_t  on_load_entry = lookup_agent_on_load(agent);
3248
3249    if (on_load_entry != NULL) {
3250      // Invoke the Agent_OnLoad function
3251      jint err = (*on_load_entry)(&main_vm, agent->options(), NULL);
3252      if (err != JNI_OK) {
3253        vm_exit_during_initialization("agent library failed to init", agent->name());
3254      }
3255    } else {
3256      vm_exit_during_initialization("Could not find Agent_OnLoad function in the agent library", agent->name());
3257    }
3258  }
3259  JvmtiExport::enter_primordial_phase();
3260}
3261
3262extern "C" {
3263  typedef void (JNICALL *Agent_OnUnload_t)(JavaVM *);
3264}
3265
3266void Threads::shutdown_vm_agents() {
3267  // Send any Agent_OnUnload notifications
3268  const char *on_unload_symbols[] = AGENT_ONUNLOAD_SYMBOLS;
3269  extern struct JavaVM_ main_vm;
3270  for (AgentLibrary* agent = Arguments::agents(); agent != NULL; agent = agent->next()) {
3271
3272    // Find the Agent_OnUnload function.
3273    for (uint symbol_index = 0; symbol_index < ARRAY_SIZE(on_unload_symbols); symbol_index++) {
3274      Agent_OnUnload_t unload_entry = CAST_TO_FN_PTR(Agent_OnUnload_t,
3275               hpi::dll_lookup(agent->os_lib(), on_unload_symbols[symbol_index]));
3276
3277      // Invoke the Agent_OnUnload function
3278      if (unload_entry != NULL) {
3279        JavaThread* thread = JavaThread::current();
3280        ThreadToNativeFromVM ttn(thread);
3281        HandleMark hm(thread);
3282        (*unload_entry)(&main_vm);
3283        break;
3284      }
3285    }
3286  }
3287}
3288
3289// Called for after the VM is initialized for -Xrun libraries which have not been converted to agent libraries
3290// Invokes JVM_OnLoad
3291void Threads::create_vm_init_libraries() {
3292  extern struct JavaVM_ main_vm;
3293  AgentLibrary* agent;
3294
3295  for (agent = Arguments::libraries(); agent != NULL; agent = agent->next()) {
3296    OnLoadEntry_t on_load_entry = lookup_jvm_on_load(agent);
3297
3298    if (on_load_entry != NULL) {
3299      // Invoke the JVM_OnLoad function
3300      JavaThread* thread = JavaThread::current();
3301      ThreadToNativeFromVM ttn(thread);
3302      HandleMark hm(thread);
3303      jint err = (*on_load_entry)(&main_vm, agent->options(), NULL);
3304      if (err != JNI_OK) {
3305        vm_exit_during_initialization("-Xrun library failed to init", agent->name());
3306      }
3307    } else {
3308      vm_exit_during_initialization("Could not find JVM_OnLoad function in -Xrun library", agent->name());
3309    }
3310  }
3311}
3312
3313// Last thread running calls java.lang.Shutdown.shutdown()
3314void JavaThread::invoke_shutdown_hooks() {
3315  HandleMark hm(this);
3316
3317  // We could get here with a pending exception, if so clear it now.
3318  if (this->has_pending_exception()) {
3319    this->clear_pending_exception();
3320  }
3321
3322  EXCEPTION_MARK;
3323  klassOop k =
3324    SystemDictionary::resolve_or_null(vmSymbolHandles::java_lang_Shutdown(),
3325                                      THREAD);
3326  if (k != NULL) {
3327    // SystemDictionary::resolve_or_null will return null if there was
3328    // an exception.  If we cannot load the Shutdown class, just don't
3329    // call Shutdown.shutdown() at all.  This will mean the shutdown hooks
3330    // and finalizers (if runFinalizersOnExit is set) won't be run.
3331    // Note that if a shutdown hook was registered or runFinalizersOnExit
3332    // was called, the Shutdown class would have already been loaded
3333    // (Runtime.addShutdownHook and runFinalizersOnExit will load it).
3334    instanceKlassHandle shutdown_klass (THREAD, k);
3335    JavaValue result(T_VOID);
3336    JavaCalls::call_static(&result,
3337                           shutdown_klass,
3338                           vmSymbolHandles::shutdown_method_name(),
3339                           vmSymbolHandles::void_method_signature(),
3340                           THREAD);
3341  }
3342  CLEAR_PENDING_EXCEPTION;
3343}
3344
3345// Threads::destroy_vm() is normally called from jni_DestroyJavaVM() when
3346// the program falls off the end of main(). Another VM exit path is through
3347// vm_exit() when the program calls System.exit() to return a value or when
3348// there is a serious error in VM. The two shutdown paths are not exactly
3349// the same, but they share Shutdown.shutdown() at Java level and before_exit()
3350// and VM_Exit op at VM level.
3351//
3352// Shutdown sequence:
3353//   + Wait until we are the last non-daemon thread to execute
3354//     <-- every thing is still working at this moment -->
3355//   + Call java.lang.Shutdown.shutdown(), which will invoke Java level
3356//        shutdown hooks, run finalizers if finalization-on-exit
3357//   + Call before_exit(), prepare for VM exit
3358//      > run VM level shutdown hooks (they are registered through JVM_OnExit(),
3359//        currently the only user of this mechanism is File.deleteOnExit())
3360//      > stop flat profiler, StatSampler, watcher thread, CMS threads,
3361//        post thread end and vm death events to JVMTI,
3362//        stop signal thread
3363//   + Call JavaThread::exit(), it will:
3364//      > release JNI handle blocks, remove stack guard pages
3365//      > remove this thread from Threads list
3366//     <-- no more Java code from this thread after this point -->
3367//   + Stop VM thread, it will bring the remaining VM to a safepoint and stop
3368//     the compiler threads at safepoint
3369//     <-- do not use anything that could get blocked by Safepoint -->
3370//   + Disable tracing at JNI/JVM barriers
3371//   + Set _vm_exited flag for threads that are still running native code
3372//   + Delete this thread
3373//   + Call exit_globals()
3374//      > deletes tty
3375//      > deletes PerfMemory resources
3376//   + Return to caller
3377
3378bool Threads::destroy_vm() {
3379  JavaThread* thread = JavaThread::current();
3380
3381  // Wait until we are the last non-daemon thread to execute
3382  { MutexLocker nu(Threads_lock);
3383    while (Threads::number_of_non_daemon_threads() > 1 )
3384      // This wait should make safepoint checks, wait without a timeout,
3385      // and wait as a suspend-equivalent condition.
3386      //
3387      // Note: If the FlatProfiler is running and this thread is waiting
3388      // for another non-daemon thread to finish, then the FlatProfiler
3389      // is waiting for the external suspend request on this thread to
3390      // complete. wait_for_ext_suspend_completion() will eventually
3391      // timeout, but that takes time. Making this wait a suspend-
3392      // equivalent condition solves that timeout problem.
3393      //
3394      Threads_lock->wait(!Mutex::_no_safepoint_check_flag, 0,
3395                         Mutex::_as_suspend_equivalent_flag);
3396  }
3397
3398  // Hang forever on exit if we are reporting an error.
3399  if (ShowMessageBoxOnError && is_error_reported()) {
3400    os::infinite_sleep();
3401  }
3402
3403  if (JDK_Version::is_jdk12x_version()) {
3404    // We are the last thread running, so check if finalizers should be run.
3405    // For 1.3 or later this is done in thread->invoke_shutdown_hooks()
3406    HandleMark rm(thread);
3407    Universe::run_finalizers_on_exit();
3408  } else {
3409    // run Java level shutdown hooks
3410    thread->invoke_shutdown_hooks();
3411  }
3412
3413  before_exit(thread);
3414
3415  thread->exit(true);
3416
3417  // Stop VM thread.
3418  {
3419    // 4945125 The vm thread comes to a safepoint during exit.
3420    // GC vm_operations can get caught at the safepoint, and the
3421    // heap is unparseable if they are caught. Grab the Heap_lock
3422    // to prevent this. The GC vm_operations will not be able to
3423    // queue until after the vm thread is dead.
3424    MutexLocker ml(Heap_lock);
3425
3426    VMThread::wait_for_vm_thread_exit();
3427    assert(SafepointSynchronize::is_at_safepoint(), "VM thread should exit at Safepoint");
3428    VMThread::destroy();
3429  }
3430
3431  // clean up ideal graph printers
3432#if defined(COMPILER2) && !defined(PRODUCT)
3433  IdealGraphPrinter::clean_up();
3434#endif
3435
3436  // Now, all Java threads are gone except daemon threads. Daemon threads
3437  // running Java code or in VM are stopped by the Safepoint. However,
3438  // daemon threads executing native code are still running.  But they
3439  // will be stopped at native=>Java/VM barriers. Note that we can't
3440  // simply kill or suspend them, as it is inherently deadlock-prone.
3441
3442#ifndef PRODUCT
3443  // disable function tracing at JNI/JVM barriers
3444  TraceHPI = false;
3445  TraceJNICalls = false;
3446  TraceJVMCalls = false;
3447  TraceRuntimeCalls = false;
3448#endif
3449
3450  VM_Exit::set_vm_exited();
3451
3452  notify_vm_shutdown();
3453
3454  delete thread;
3455
3456  // exit_globals() will delete tty
3457  exit_globals();
3458
3459  return true;
3460}
3461
3462
3463jboolean Threads::is_supported_jni_version_including_1_1(jint version) {
3464  if (version == JNI_VERSION_1_1) return JNI_TRUE;
3465  return is_supported_jni_version(version);
3466}
3467
3468
3469jboolean Threads::is_supported_jni_version(jint version) {
3470  if (version == JNI_VERSION_1_2) return JNI_TRUE;
3471  if (version == JNI_VERSION_1_4) return JNI_TRUE;
3472  if (version == JNI_VERSION_1_6) return JNI_TRUE;
3473  return JNI_FALSE;
3474}
3475
3476
3477void Threads::add(JavaThread* p, bool force_daemon) {
3478  // The threads lock must be owned at this point
3479  assert_locked_or_safepoint(Threads_lock);
3480  p->set_next(_thread_list);
3481  _thread_list = p;
3482  _number_of_threads++;
3483  oop threadObj = p->threadObj();
3484  bool daemon = true;
3485  // Bootstrapping problem: threadObj can be null for initial
3486  // JavaThread (or for threads attached via JNI)
3487  if ((!force_daemon) && (threadObj == NULL || !java_lang_Thread::is_daemon(threadObj))) {
3488    _number_of_non_daemon_threads++;
3489    daemon = false;
3490  }
3491
3492  ThreadService::add_thread(p, daemon);
3493
3494  // Possible GC point.
3495  Events::log("Thread added: " INTPTR_FORMAT, p);
3496}
3497
3498void Threads::remove(JavaThread* p) {
3499  // Extra scope needed for Thread_lock, so we can check
3500  // that we do not remove thread without safepoint code notice
3501  { MutexLocker ml(Threads_lock);
3502
3503    assert(includes(p), "p must be present");
3504
3505    JavaThread* current = _thread_list;
3506    JavaThread* prev    = NULL;
3507
3508    while (current != p) {
3509      prev    = current;
3510      current = current->next();
3511    }
3512
3513    if (prev) {
3514      prev->set_next(current->next());
3515    } else {
3516      _thread_list = p->next();
3517    }
3518    _number_of_threads--;
3519    oop threadObj = p->threadObj();
3520    bool daemon = true;
3521    if (threadObj == NULL || !java_lang_Thread::is_daemon(threadObj)) {
3522      _number_of_non_daemon_threads--;
3523      daemon = false;
3524
3525      // Only one thread left, do a notify on the Threads_lock so a thread waiting
3526      // on destroy_vm will wake up.
3527      if (number_of_non_daemon_threads() == 1)
3528        Threads_lock->notify_all();
3529    }
3530    ThreadService::remove_thread(p, daemon);
3531
3532    // Make sure that safepoint code disregard this thread. This is needed since
3533    // the thread might mess around with locks after this point. This can cause it
3534    // to do callbacks into the safepoint code. However, the safepoint code is not aware
3535    // of this thread since it is removed from the queue.
3536    p->set_terminated_value();
3537  } // unlock Threads_lock
3538
3539  // Since Events::log uses a lock, we grab it outside the Threads_lock
3540  Events::log("Thread exited: " INTPTR_FORMAT, p);
3541}
3542
3543// Threads_lock must be held when this is called (or must be called during a safepoint)
3544bool Threads::includes(JavaThread* p) {
3545  assert(Threads_lock->is_locked(), "sanity check");
3546  ALL_JAVA_THREADS(q) {
3547    if (q == p ) {
3548      return true;
3549    }
3550  }
3551  return false;
3552}
3553
3554// Operations on the Threads list for GC.  These are not explicitly locked,
3555// but the garbage collector must provide a safe context for them to run.
3556// In particular, these things should never be called when the Threads_lock
3557// is held by some other thread. (Note: the Safepoint abstraction also
3558// uses the Threads_lock to gurantee this property. It also makes sure that
3559// all threads gets blocked when exiting or starting).
3560
3561void Threads::oops_do(OopClosure* f) {
3562  ALL_JAVA_THREADS(p) {
3563    p->oops_do(f);
3564  }
3565  VMThread::vm_thread()->oops_do(f);
3566}
3567
3568void Threads::possibly_parallel_oops_do(OopClosure* f) {
3569  // Introduce a mechanism allowing parallel threads to claim threads as
3570  // root groups.  Overhead should be small enough to use all the time,
3571  // even in sequential code.
3572  SharedHeap* sh = SharedHeap::heap();
3573  bool is_par = (sh->n_par_threads() > 0);
3574  int cp = SharedHeap::heap()->strong_roots_parity();
3575  ALL_JAVA_THREADS(p) {
3576    if (p->claim_oops_do(is_par, cp)) {
3577      p->oops_do(f);
3578    }
3579  }
3580  VMThread* vmt = VMThread::vm_thread();
3581  if (vmt->claim_oops_do(is_par, cp))
3582    vmt->oops_do(f);
3583}
3584
3585#ifndef SERIALGC
3586// Used by ParallelScavenge
3587void Threads::create_thread_roots_tasks(GCTaskQueue* q) {
3588  ALL_JAVA_THREADS(p) {
3589    q->enqueue(new ThreadRootsTask(p));
3590  }
3591  q->enqueue(new ThreadRootsTask(VMThread::vm_thread()));
3592}
3593
3594// Used by Parallel Old
3595void Threads::create_thread_roots_marking_tasks(GCTaskQueue* q) {
3596  ALL_JAVA_THREADS(p) {
3597    q->enqueue(new ThreadRootsMarkingTask(p));
3598  }
3599  q->enqueue(new ThreadRootsMarkingTask(VMThread::vm_thread()));
3600}
3601#endif // SERIALGC
3602
3603void Threads::nmethods_do() {
3604  ALL_JAVA_THREADS(p) {
3605    p->nmethods_do();
3606  }
3607  VMThread::vm_thread()->nmethods_do();
3608}
3609
3610void Threads::gc_epilogue() {
3611  ALL_JAVA_THREADS(p) {
3612    p->gc_epilogue();
3613  }
3614}
3615
3616void Threads::gc_prologue() {
3617  ALL_JAVA_THREADS(p) {
3618    p->gc_prologue();
3619  }
3620}
3621
3622void Threads::deoptimized_wrt_marked_nmethods() {
3623  ALL_JAVA_THREADS(p) {
3624    p->deoptimized_wrt_marked_nmethods();
3625  }
3626}
3627
3628
3629// Get count Java threads that are waiting to enter the specified monitor.
3630GrowableArray<JavaThread*>* Threads::get_pending_threads(int count,
3631  address monitor, bool doLock) {
3632  assert(doLock || SafepointSynchronize::is_at_safepoint(),
3633    "must grab Threads_lock or be at safepoint");
3634  GrowableArray<JavaThread*>* result = new GrowableArray<JavaThread*>(count);
3635
3636  int i = 0;
3637  {
3638    MutexLockerEx ml(doLock ? Threads_lock : NULL);
3639    ALL_JAVA_THREADS(p) {
3640      if (p->is_Compiler_thread()) continue;
3641
3642      address pending = (address)p->current_pending_monitor();
3643      if (pending == monitor) {             // found a match
3644        if (i < count) result->append(p);   // save the first count matches
3645        i++;
3646      }
3647    }
3648  }
3649  return result;
3650}
3651
3652
3653JavaThread *Threads::owning_thread_from_monitor_owner(address owner, bool doLock) {
3654  assert(doLock ||
3655         Threads_lock->owned_by_self() ||
3656         SafepointSynchronize::is_at_safepoint(),
3657         "must grab Threads_lock or be at safepoint");
3658
3659  // NULL owner means not locked so we can skip the search
3660  if (owner == NULL) return NULL;
3661
3662  {
3663    MutexLockerEx ml(doLock ? Threads_lock : NULL);
3664    ALL_JAVA_THREADS(p) {
3665      // first, see if owner is the address of a Java thread
3666      if (owner == (address)p) return p;
3667    }
3668  }
3669  assert(UseHeavyMonitors == false, "Did not find owning Java thread with UseHeavyMonitors enabled");
3670  if (UseHeavyMonitors) return NULL;
3671
3672  //
3673  // If we didn't find a matching Java thread and we didn't force use of
3674  // heavyweight monitors, then the owner is the stack address of the
3675  // Lock Word in the owning Java thread's stack.
3676  //
3677  // We can't use Thread::is_lock_owned() or Thread::lock_is_in_stack() because
3678  // those routines rely on the "current" stack pointer. That would be our
3679  // stack pointer which is not relevant to the question. Instead we use the
3680  // highest lock ever entered by the thread and find the thread that is
3681  // higher than and closest to our target stack address.
3682  //
3683  address    least_diff = 0;
3684  bool       least_diff_initialized = false;
3685  JavaThread* the_owner = NULL;
3686  {
3687    MutexLockerEx ml(doLock ? Threads_lock : NULL);
3688    ALL_JAVA_THREADS(q) {
3689      address addr = q->highest_lock();
3690      if (addr == NULL || addr < owner) continue;  // thread has entered no monitors or is too low
3691      address diff = (address)(addr - owner);
3692      if (!least_diff_initialized || diff < least_diff) {
3693        least_diff_initialized = true;
3694        least_diff = diff;
3695        the_owner = q;
3696      }
3697    }
3698  }
3699  assert(the_owner != NULL, "Did not find owning Java thread for lock word address");
3700  return the_owner;
3701}
3702
3703// Threads::print_on() is called at safepoint by VM_PrintThreads operation.
3704void Threads::print_on(outputStream* st, bool print_stacks, bool internal_format, bool print_concurrent_locks) {
3705  char buf[32];
3706  st->print_cr(os::local_time_string(buf, sizeof(buf)));
3707
3708  st->print_cr("Full thread dump %s (%s %s):",
3709                Abstract_VM_Version::vm_name(),
3710                Abstract_VM_Version::vm_release(),
3711                Abstract_VM_Version::vm_info_string()
3712               );
3713  st->cr();
3714
3715#ifndef SERIALGC
3716  // Dump concurrent locks
3717  ConcurrentLocksDump concurrent_locks;
3718  if (print_concurrent_locks) {
3719    concurrent_locks.dump_at_safepoint();
3720  }
3721#endif // SERIALGC
3722
3723  ALL_JAVA_THREADS(p) {
3724    ResourceMark rm;
3725    p->print_on(st);
3726    if (print_stacks) {
3727      if (internal_format) {
3728        p->trace_stack();
3729      } else {
3730        p->print_stack_on(st);
3731      }
3732    }
3733    st->cr();
3734#ifndef SERIALGC
3735    if (print_concurrent_locks) {
3736      concurrent_locks.print_locks_on(p, st);
3737    }
3738#endif // SERIALGC
3739  }
3740
3741  VMThread::vm_thread()->print_on(st);
3742  st->cr();
3743  Universe::heap()->print_gc_threads_on(st);
3744  WatcherThread* wt = WatcherThread::watcher_thread();
3745  if (wt != NULL) wt->print_on(st);
3746  st->cr();
3747  CompileBroker::print_compiler_threads_on(st);
3748  st->flush();
3749}
3750
3751// Threads::print_on_error() is called by fatal error handler. It's possible
3752// that VM is not at safepoint and/or current thread is inside signal handler.
3753// Don't print stack trace, as the stack may not be walkable. Don't allocate
3754// memory (even in resource area), it might deadlock the error handler.
3755void Threads::print_on_error(outputStream* st, Thread* current, char* buf, int buflen) {
3756  bool found_current = false;
3757  st->print_cr("Java Threads: ( => current thread )");
3758  ALL_JAVA_THREADS(thread) {
3759    bool is_current = (current == thread);
3760    found_current = found_current || is_current;
3761
3762    st->print("%s", is_current ? "=>" : "  ");
3763
3764    st->print(PTR_FORMAT, thread);
3765    st->print(" ");
3766    thread->print_on_error(st, buf, buflen);
3767    st->cr();
3768  }
3769  st->cr();
3770
3771  st->print_cr("Other Threads:");
3772  if (VMThread::vm_thread()) {
3773    bool is_current = (current == VMThread::vm_thread());
3774    found_current = found_current || is_current;
3775    st->print("%s", current == VMThread::vm_thread() ? "=>" : "  ");
3776
3777    st->print(PTR_FORMAT, VMThread::vm_thread());
3778    st->print(" ");
3779    VMThread::vm_thread()->print_on_error(st, buf, buflen);
3780    st->cr();
3781  }
3782  WatcherThread* wt = WatcherThread::watcher_thread();
3783  if (wt != NULL) {
3784    bool is_current = (current == wt);
3785    found_current = found_current || is_current;
3786    st->print("%s", is_current ? "=>" : "  ");
3787
3788    st->print(PTR_FORMAT, wt);
3789    st->print(" ");
3790    wt->print_on_error(st, buf, buflen);
3791    st->cr();
3792  }
3793  if (!found_current) {
3794    st->cr();
3795    st->print("=>" PTR_FORMAT " (exited) ", current);
3796    current->print_on_error(st, buf, buflen);
3797    st->cr();
3798  }
3799}
3800
3801
3802// Lifecycle management for TSM ParkEvents.
3803// ParkEvents are type-stable (TSM).
3804// In our particular implementation they happen to be immortal.
3805//
3806// We manage concurrency on the FreeList with a CAS-based
3807// detach-modify-reattach idiom that avoids the ABA problems
3808// that would otherwise be present in a simple CAS-based
3809// push-pop implementation.   (push-one and pop-all)
3810//
3811// Caveat: Allocate() and Release() may be called from threads
3812// other than the thread associated with the Event!
3813// If we need to call Allocate() when running as the thread in
3814// question then look for the PD calls to initialize native TLS.
3815// Native TLS (Win32/Linux/Solaris) can only be initialized or
3816// accessed by the associated thread.
3817// See also pd_initialize().
3818//
3819// Note that we could defer associating a ParkEvent with a thread
3820// until the 1st time the thread calls park().  unpark() calls to
3821// an unprovisioned thread would be ignored.  The first park() call
3822// for a thread would allocate and associate a ParkEvent and return
3823// immediately.
3824
3825volatile int ParkEvent::ListLock = 0 ;
3826ParkEvent * volatile ParkEvent::FreeList = NULL ;
3827
3828ParkEvent * ParkEvent::Allocate (Thread * t) {
3829  // In rare cases -- JVM_RawMonitor* operations -- we can find t == null.
3830  ParkEvent * ev ;
3831
3832  // Start by trying to recycle an existing but unassociated
3833  // ParkEvent from the global free list.
3834  for (;;) {
3835    ev = FreeList ;
3836    if (ev == NULL) break ;
3837    // 1: Detach - sequester or privatize the list
3838    // Tantamount to ev = Swap (&FreeList, NULL)
3839    if (Atomic::cmpxchg_ptr (NULL, &FreeList, ev) != ev) {
3840       continue ;
3841    }
3842
3843    // We've detached the list.  The list in-hand is now
3844    // local to this thread.   This thread can operate on the
3845    // list without risk of interference from other threads.
3846    // 2: Extract -- pop the 1st element from the list.
3847    ParkEvent * List = ev->FreeNext ;
3848    if (List == NULL) break ;
3849    for (;;) {
3850        // 3: Try to reattach the residual list
3851        guarantee (List != NULL, "invariant") ;
3852        ParkEvent * Arv =  (ParkEvent *) Atomic::cmpxchg_ptr (List, &FreeList, NULL) ;
3853        if (Arv == NULL) break ;
3854
3855        // New nodes arrived.  Try to detach the recent arrivals.
3856        if (Atomic::cmpxchg_ptr (NULL, &FreeList, Arv) != Arv) {
3857            continue ;
3858        }
3859        guarantee (Arv != NULL, "invariant") ;
3860        // 4: Merge Arv into List
3861        ParkEvent * Tail = List ;
3862        while (Tail->FreeNext != NULL) Tail = Tail->FreeNext ;
3863        Tail->FreeNext = Arv ;
3864    }
3865    break ;
3866  }
3867
3868  if (ev != NULL) {
3869    guarantee (ev->AssociatedWith == NULL, "invariant") ;
3870  } else {
3871    // Do this the hard way -- materialize a new ParkEvent.
3872    // In rare cases an allocating thread might detach a long list --
3873    // installing null into FreeList -- and then stall or be obstructed.
3874    // A 2nd thread calling Allocate() would see FreeList == null.
3875    // The list held privately by the 1st thread is unavailable to the 2nd thread.
3876    // In that case the 2nd thread would have to materialize a new ParkEvent,
3877    // even though free ParkEvents existed in the system.  In this case we end up
3878    // with more ParkEvents in circulation than we need, but the race is
3879    // rare and the outcome is benign.  Ideally, the # of extant ParkEvents
3880    // is equal to the maximum # of threads that existed at any one time.
3881    // Because of the race mentioned above, segments of the freelist
3882    // can be transiently inaccessible.  At worst we may end up with the
3883    // # of ParkEvents in circulation slightly above the ideal.
3884    // Note that if we didn't have the TSM/immortal constraint, then
3885    // when reattaching, above, we could trim the list.
3886    ev = new ParkEvent () ;
3887    guarantee ((intptr_t(ev) & 0xFF) == 0, "invariant") ;
3888  }
3889  ev->reset() ;                     // courtesy to caller
3890  ev->AssociatedWith = t ;          // Associate ev with t
3891  ev->FreeNext       = NULL ;
3892  return ev ;
3893}
3894
3895void ParkEvent::Release (ParkEvent * ev) {
3896  if (ev == NULL) return ;
3897  guarantee (ev->FreeNext == NULL      , "invariant") ;
3898  ev->AssociatedWith = NULL ;
3899  for (;;) {
3900    // Push ev onto FreeList
3901    // The mechanism is "half" lock-free.
3902    ParkEvent * List = FreeList ;
3903    ev->FreeNext = List ;
3904    if (Atomic::cmpxchg_ptr (ev, &FreeList, List) == List) break ;
3905  }
3906}
3907
3908// Override operator new and delete so we can ensure that the
3909// least significant byte of ParkEvent addresses is 0.
3910// Beware that excessive address alignment is undesirable
3911// as it can result in D$ index usage imbalance as
3912// well as bank access imbalance on Niagara-like platforms,
3913// although Niagara's hash function should help.
3914
3915void * ParkEvent::operator new (size_t sz) {
3916  return (void *) ((intptr_t (CHeapObj::operator new (sz + 256)) + 256) & -256) ;
3917}
3918
3919void ParkEvent::operator delete (void * a) {
3920  // ParkEvents are type-stable and immortal ...
3921  ShouldNotReachHere();
3922}
3923
3924
3925// 6399321 As a temporary measure we copied & modified the ParkEvent::
3926// allocate() and release() code for use by Parkers.  The Parker:: forms
3927// will eventually be removed as we consolide and shift over to ParkEvents
3928// for both builtin synchronization and JSR166 operations.
3929
3930volatile int Parker::ListLock = 0 ;
3931Parker * volatile Parker::FreeList = NULL ;
3932
3933Parker * Parker::Allocate (JavaThread * t) {
3934  guarantee (t != NULL, "invariant") ;
3935  Parker * p ;
3936
3937  // Start by trying to recycle an existing but unassociated
3938  // Parker from the global free list.
3939  for (;;) {
3940    p = FreeList ;
3941    if (p  == NULL) break ;
3942    // 1: Detach
3943    // Tantamount to p = Swap (&FreeList, NULL)
3944    if (Atomic::cmpxchg_ptr (NULL, &FreeList, p) != p) {
3945       continue ;
3946    }
3947
3948    // We've detached the list.  The list in-hand is now
3949    // local to this thread.   This thread can operate on the
3950    // list without risk of interference from other threads.
3951    // 2: Extract -- pop the 1st element from the list.
3952    Parker * List = p->FreeNext ;
3953    if (List == NULL) break ;
3954    for (;;) {
3955        // 3: Try to reattach the residual list
3956        guarantee (List != NULL, "invariant") ;
3957        Parker * Arv =  (Parker *) Atomic::cmpxchg_ptr (List, &FreeList, NULL) ;
3958        if (Arv == NULL) break ;
3959
3960        // New nodes arrived.  Try to detach the recent arrivals.
3961        if (Atomic::cmpxchg_ptr (NULL, &FreeList, Arv) != Arv) {
3962            continue ;
3963        }
3964        guarantee (Arv != NULL, "invariant") ;
3965        // 4: Merge Arv into List
3966        Parker * Tail = List ;
3967        while (Tail->FreeNext != NULL) Tail = Tail->FreeNext ;
3968        Tail->FreeNext = Arv ;
3969    }
3970    break ;
3971  }
3972
3973  if (p != NULL) {
3974    guarantee (p->AssociatedWith == NULL, "invariant") ;
3975  } else {
3976    // Do this the hard way -- materialize a new Parker..
3977    // In rare cases an allocating thread might detach
3978    // a long list -- installing null into FreeList --and
3979    // then stall.  Another thread calling Allocate() would see
3980    // FreeList == null and then invoke the ctor.  In this case we
3981    // end up with more Parkers in circulation than we need, but
3982    // the race is rare and the outcome is benign.
3983    // Ideally, the # of extant Parkers is equal to the
3984    // maximum # of threads that existed at any one time.
3985    // Because of the race mentioned above, segments of the
3986    // freelist can be transiently inaccessible.  At worst
3987    // we may end up with the # of Parkers in circulation
3988    // slightly above the ideal.
3989    p = new Parker() ;
3990  }
3991  p->AssociatedWith = t ;          // Associate p with t
3992  p->FreeNext       = NULL ;
3993  return p ;
3994}
3995
3996
3997void Parker::Release (Parker * p) {
3998  if (p == NULL) return ;
3999  guarantee (p->AssociatedWith != NULL, "invariant") ;
4000  guarantee (p->FreeNext == NULL      , "invariant") ;
4001  p->AssociatedWith = NULL ;
4002  for (;;) {
4003    // Push p onto FreeList
4004    Parker * List = FreeList ;
4005    p->FreeNext = List ;
4006    if (Atomic::cmpxchg_ptr (p, &FreeList, List) == List) break ;
4007  }
4008}
4009
4010void Threads::verify() {
4011  ALL_JAVA_THREADS(p) {
4012    p->verify();
4013  }
4014  VMThread* thread = VMThread::vm_thread();
4015  if (thread != NULL) thread->verify();
4016}
4017