/*

 * Copyright (c) 1997, 2013, Oracle and/or its affiliates. All rights reserved.

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.

 *

 * This code is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 *

 */

#include "precompiled.hpp"

#include "classfile/classLoader.hpp"

#include "classfile/javaClasses.hpp"

#include "classfile/systemDictionary.hpp"

#include "classfile/vmSymbols.hpp"

#include "code/scopeDesc.hpp"

#include "compiler/compileBroker.hpp"

#include "interpreter/interpreter.hpp"

#include "interpreter/linkResolver.hpp"

#include "interpreter/oopMapCache.hpp"

#include "jvmtifiles/jvmtiEnv.hpp"

#include "memory/gcLocker.inline.hpp"

#include "memory/metaspaceShared.hpp"

#include "memory/oopFactory.hpp"

#include "memory/universe.inline.hpp"

#include "oops/instanceKlass.hpp"

#include "oops/objArrayOop.hpp"

#include "oops/oop.inline.hpp"

#include "oops/symbol.hpp"

#include "prims/jvm_misc.hpp"

#include "prims/jvmtiExport.hpp"

#include "prims/jvmtiThreadState.hpp"

#include "prims/privilegedStack.hpp"

#include "runtime/arguments.hpp"

#include "runtime/biasedLocking.hpp"

#include "runtime/deoptimization.hpp"

#include "runtime/fprofiler.hpp"

#include "runtime/frame.inline.hpp"

#include "runtime/init.hpp"

#include "runtime/interfaceSupport.hpp"

#include "runtime/java.hpp"

#include "runtime/javaCalls.hpp"

#include "runtime/jniPeriodicChecker.hpp"

#include "runtime/memprofiler.hpp"

#include "runtime/mutexLocker.hpp"

#include "runtime/objectMonitor.hpp"

#include "runtime/osThread.hpp"

#include "runtime/safepoint.hpp"

#include "runtime/sharedRuntime.hpp"

#include "runtime/statSampler.hpp"

#include "runtime/stubRoutines.hpp"

#include "runtime/task.hpp"

#include "runtime/thread.inline.hpp"

#include "runtime/threadCritical.hpp"

#include "runtime/threadLocalStorage.hpp"

#include "runtime/vframe.hpp"

#include "runtime/vframeArray.hpp"

#include "runtime/vframe_hp.hpp"

#include "runtime/vmThread.hpp"

#include "runtime/vm_operations.hpp"

#include "services/attachListener.hpp"

#include "services/management.hpp"

#include "services/memTracker.hpp"

#include "services/threadService.hpp"

#include "trace/tracing.hpp"

#include "trace/traceMacros.hpp"

#include "utilities/defaultStream.hpp"

#include "utilities/dtrace.hpp"

#include "utilities/events.hpp"

#include "utilities/preserveException.hpp"

#include "utilities/macros.hpp"

#ifdef TARGET_OS_FAMILY_linux

# include "os_linux.inline.hpp"

#endif

#ifdef TARGET_OS_FAMILY_solaris

# include "os_solaris.inline.hpp"

#endif

#ifdef TARGET_OS_FAMILY_windows

# include "os_windows.inline.hpp"

#endif

#ifdef TARGET_OS_FAMILY_bsd

# include "os_bsd.inline.hpp"

#endif

#if INCLUDE_ALL_GCS

#include "gc_implementation/concurrentMarkSweep/concurrentMarkSweepThread.hpp"

#include "gc_implementation/g1/concurrentMarkThread.inline.hpp"

#include "gc_implementation/parallelScavenge/pcTasks.hpp"

#endif // INCLUDE_ALL_GCS

#ifdef COMPILER1

#include "c1/c1_Compiler.hpp"

#endif

#ifdef COMPILER2

#include "opto/c2compiler.hpp"

#include "opto/idealGraphPrinter.hpp"

#endif

#ifdef DTRACE_ENABLED

// Only bother with this argument setup if dtrace is available

#ifndef USDT2

HS_DTRACE_PROBE_DECL(hotspot, vm__init__begin);

HS_DTRACE_PROBE_DECL(hotspot, vm__init__end);

HS_DTRACE_PROBE_DECL5(hotspot, thread__start, char*, intptr_t,

  intptr_t, intptr_t, bool);

HS_DTRACE_PROBE_DECL5(hotspot, thread__stop, char*, intptr_t,

  intptr_t, intptr_t, bool);

#define DTRACE_THREAD_PROBE(probe, javathread)                             \

  {                                                                        \

    ResourceMark rm(this);                                                 \

    int len = 0;                                                           \

    const char* name = (javathread)->get_thread_name();                    \

    len = strlen(name);                                                    \

    HS_DTRACE_PROBE5(hotspot, thread__##probe,                             \

      name, len,                                                           \

      java_lang_Thread::thread_id((javathread)->threadObj()),              \

      (javathread)->osthread()->thread_id(),                               \

      java_lang_Thread::is_daemon((javathread)->threadObj()));             \

  }

#else /* USDT2 */

#define HOTSPOT_THREAD_PROBE_start HOTSPOT_THREAD_PROBE_START

#define HOTSPOT_THREAD_PROBE_stop HOTSPOT_THREAD_PROBE_STOP

#define DTRACE_THREAD_PROBE(probe, javathread)                             \

  {                                                                        \

    ResourceMark rm(this);                                                 \

    int len = 0;                                                           \

    const char* name = (javathread)->get_thread_name();                    \

    len = strlen(name);                                                    \

    HOTSPOT_THREAD_PROBE_##probe(  /* probe = start, stop */               \

      (char *) name, len,                                                           \

      java_lang_Thread::thread_id((javathread)->threadObj()),              \

      (uintptr_t) (javathread)->osthread()->thread_id(),                               \

      java_lang_Thread::is_daemon((javathread)->threadObj()));             \

  }

#endif /* USDT2 */

#else //  ndef DTRACE_ENABLED

#define DTRACE_THREAD_PROBE(probe, javathread)

#endif // ndef DTRACE_ENABLED

// Class hierarchy

// - Thread

//   - VMThread

//   - WatcherThread

//   - ConcurrentMarkSweepThread

//   - JavaThread

//     - CompilerThread

// ======= Thread ========

// Support for forcing alignment of thread objects for biased locking

void* Thread::allocate(size_t size, bool throw_excpt, MEMFLAGS flags) {

  if (UseBiasedLocking) {

    const int alignment = markOopDesc::biased_lock_alignment;

    size_t aligned_size = size + (alignment - sizeof(intptr_t));

    void* real_malloc_addr = throw_excpt? AllocateHeap(aligned_size, flags, CURRENT_PC)

                                          : AllocateHeap(aligned_size, flags, CURRENT_PC,

                                              AllocFailStrategy::RETURN_NULL);

    void* aligned_addr     = (void*) align_size_up((intptr_t) real_malloc_addr, alignment);

    assert(((uintptr_t) aligned_addr + (uintptr_t) size) <=

           ((uintptr_t) real_malloc_addr + (uintptr_t) aligned_size),

           "JavaThread alignment code overflowed allocated storage");

    if (TraceBiasedLocking) {

      if (aligned_addr != real_malloc_addr)

        tty->print_cr("Aligned thread " INTPTR_FORMAT " to " INTPTR_FORMAT,

                      real_malloc_addr, aligned_addr);

    }

    ((Thread*) aligned_addr)->_real_malloc_address = real_malloc_addr;

    return aligned_addr;

  } else {

    return throw_excpt? AllocateHeap(size, flags, CURRENT_PC)

                       : AllocateHeap(size, flags, CURRENT_PC, AllocFailStrategy::RETURN_NULL);

  }

}

void Thread::operator delete(void* p) {

  if (UseBiasedLocking) {

    void* real_malloc_addr = ((Thread*) p)->_real_malloc_address;

    FreeHeap(real_malloc_addr, mtThread);

  } else {

    FreeHeap(p, mtThread);

  }

}

// Base class for all threads: VMThread, WatcherThread, ConcurrentMarkSweepThread,

// JavaThread

Thread::Thread() {

  // stack and get_thread

  set_stack_base(NULL);

  set_stack_size(0);

  set_self_raw_id(0);

  set_lgrp_id(-1);

  // allocated data structures

  set_osthread(NULL);

  set_resource_area(new (mtThread)ResourceArea());

  DEBUG_ONLY(_current_resource_mark = NULL;)

  set_handle_area(new (mtThread) HandleArea(NULL));

  set_metadata_handles(new (ResourceObj::C_HEAP, mtClass) GrowableArray<Metadata*>(30, true));

  set_active_handles(NULL);

  set_free_handle_block(NULL);

  set_last_handle_mark(NULL);

  // This initial value ==> never claimed.

  _oops_do_parity = 0;

  // the handle mark links itself to last_handle_mark

  new HandleMark(this);

  // plain initialization

  debug_only(_owned_locks = NULL;)

  debug_only(_allow_allocation_count = 0;)

  NOT_PRODUCT(_allow_safepoint_count = 0;)

  NOT_PRODUCT(_skip_gcalot = false;)

  CHECK_UNHANDLED_OOPS_ONLY(_gc_locked_out_count = 0;)

  _jvmti_env_iteration_count = 0;

  set_allocated_bytes(0);

  _vm_operation_started_count = 0;

  _vm_operation_completed_count = 0;

  _current_pending_monitor = NULL;

  _current_pending_monitor_is_from_java = true;

  _current_waiting_monitor = NULL;

  _num_nested_signal = 0;

  omFreeList = NULL ;

  omFreeCount = 0 ;

  omFreeProvision = 32 ;

  omInUseList = NULL ;

  omInUseCount = 0 ;

#ifdef ASSERT

  _visited_for_critical_count = false;

#endif

  _SR_lock = new Monitor(Mutex::suspend_resume, "SR_lock", true);

  _suspend_flags = 0;

  // thread-specific hashCode stream generator state - Marsaglia shift-xor form

  _hashStateX = os::random() ;

  _hashStateY = 842502087 ;

  _hashStateZ = 0x8767 ;    // (int)(3579807591LL & 0xffff) ;

  _hashStateW = 273326509 ;

  _OnTrap   = 0 ;

  _schedctl = NULL ;

  _Stalled  = 0 ;

  _TypeTag  = 0x2BAD ;

  // Many of the following fields are effectively final - immutable

  // Note that nascent threads can't use the Native Monitor-Mutex

  // construct until the _MutexEvent is initialized ...

  // CONSIDER: instead of using a fixed set of purpose-dedicated ParkEvents

  // we might instead use a stack of ParkEvents that we could provision on-demand.

  // The stack would act as a cache to avoid calls to ParkEvent::Allocate()

  // and ::Release()

  _ParkEvent   = ParkEvent::Allocate (this) ;

  _SleepEvent  = ParkEvent::Allocate (this) ;

  _MutexEvent  = ParkEvent::Allocate (this) ;

  _MuxEvent    = ParkEvent::Allocate (this) ;

#ifdef CHECK_UNHANDLED_OOPS

  if (CheckUnhandledOops) {

    _unhandled_oops = new UnhandledOops(this);

  }

#endif // CHECK_UNHANDLED_OOPS

#ifdef ASSERT

  if (UseBiasedLocking) {

    assert((((uintptr_t) this) & (markOopDesc::biased_lock_alignment - 1)) == 0, "forced alignment of thread object failed");

    assert(this == _real_malloc_address ||

           this == (void*) align_size_up((intptr_t) _real_malloc_address, markOopDesc::biased_lock_alignment),

           "bug in forced alignment of thread objects");

  }

#endif /* ASSERT */

}

void Thread::initialize_thread_local_storage() {

  // Note: Make sure this method only calls

  // non-blocking operations. Otherwise, it might not work

  // with the thread-startup/safepoint interaction.

  // During Java thread startup, safepoint code should allow this

  // method to complete because it may need to allocate memory to

  // store information for the new thread.

  // initialize structure dependent on thread local storage

  ThreadLocalStorage::set_thread(this);

}

void Thread::record_stack_base_and_size() {

  set_stack_base(os::current_stack_base());

  set_stack_size(os::current_stack_size());

  // CR 7190089: on Solaris, primordial thread's stack is adjusted

  // in initialize_thread(). Without the adjustment, stack size is

  // incorrect if stack is set to unlimited (ulimit -s unlimited).

  // So far, only Solaris has real implementation of initialize_thread().

  //

  // set up any platform-specific state.

  os::initialize_thread(this);

#if INCLUDE_NMT

  // record thread's native stack, stack grows downward

  address stack_low_addr = stack_base() - stack_size();

  MemTracker::record_thread_stack(stack_low_addr, stack_size(), this,

      CURRENT_PC);

#endif // INCLUDE_NMT

}

Thread::~Thread() {

  // Reclaim the objectmonitors from the omFreeList of the moribund thread.

  ObjectSynchronizer::omFlush (this) ;

  EVENT_THREAD_DESTRUCT(this);

  // stack_base can be NULL if the thread is never started or exited before

  // record_stack_base_and_size called. Although, we would like to ensure

  // that all started threads do call record_stack_base_and_size(), there is

  // not proper way to enforce that.

#if INCLUDE_NMT

  if (_stack_base != NULL) {

    address low_stack_addr = stack_base() - stack_size();

    MemTracker::release_thread_stack(low_stack_addr, stack_size(), this);

#ifdef ASSERT

    set_stack_base(NULL);

#endif

  }

#endif // INCLUDE_NMT

  // deallocate data structures

  delete resource_area();

  // since the handle marks are using the handle area, we have to deallocated the root

  // handle mark before deallocating the thread's handle area,

  assert(last_handle_mark() != NULL, "check we have an element");

  delete last_handle_mark();

  assert(last_handle_mark() == NULL, "check we have reached the end");

  // It's possible we can encounter a null _ParkEvent, etc., in stillborn threads.

  // We NULL out the fields for good hygiene.

  ParkEvent::Release (_ParkEvent)   ; _ParkEvent   = NULL ;

  ParkEvent::Release (_SleepEvent)  ; _SleepEvent  = NULL ;

  ParkEvent::Release (_MutexEvent)  ; _MutexEvent  = NULL ;

  ParkEvent::Release (_MuxEvent)    ; _MuxEvent    = NULL ;

  delete handle_area();

  delete metadata_handles();

  // osthread() can be NULL, if creation of thread failed.

  if (osthread() != NULL) os::free_thread(osthread());

  delete _SR_lock;

  // clear thread local storage if the Thread is deleting itself

  if (this == Thread::current()) {

    ThreadLocalStorage::set_thread(NULL);

  } else {

    // In the case where we're not the current thread, invalidate all the

    // caches in case some code tries to get the current thread or the

    // thread that was destroyed, and gets stale information.

    ThreadLocalStorage::invalidate_all();

  }

  CHECK_UNHANDLED_OOPS_ONLY(if (CheckUnhandledOops) delete unhandled_oops();)

}

// NOTE: dummy function for assertion purpose.

void Thread::run() {

  ShouldNotReachHere();

}

#ifdef ASSERT

// Private method to check for dangling thread pointer

void check_for_dangling_thread_pointer(Thread *thread) {

 assert(!thread->is_Java_thread() || Thread::current() == thread || Threads_lock->owned_by_self(),

         "possibility of dangling Thread pointer");

}

#endif

#ifndef PRODUCT

// Tracing method for basic thread operations

void Thread::trace(const char* msg, const Thread* const thread) {

  if (!TraceThreadEvents) return;

  ResourceMark rm;

  ThreadCritical tc;

  const char *name = "non-Java thread";

  int prio = -1;

  if (thread->is_Java_thread()

      && !thread->is_Compiler_thread()) {

    // The Threads_lock must be held to get information about

    // this thread but may not be in some situations when

    // tracing  thread events.

    bool release_Threads_lock = false;

    if (!Threads_lock->owned_by_self()) {

      Threads_lock->lock();

      release_Threads_lock = true;

    }

    JavaThread* jt = (JavaThread *)thread;

    name = (char *)jt->get_thread_name();

    oop thread_oop = jt->threadObj();

    if (thread_oop != NULL) {

      prio = java_lang_Thread::priority(thread_oop);

    }

    if (release_Threads_lock) {

      Threads_lock->unlock();

    }

  }

  tty->print_cr("Thread::%s " INTPTR_FORMAT " [%lx] %s (prio: %d)", msg, thread, thread->osthread()->thread_id(), name, prio);

}

#endif

ThreadPriority Thread::get_priority(const Thread* const thread) {

  trace("get priority", thread);

  ThreadPriority priority;

  // Can return an error!

  (void)os::get_priority(thread, priority);

  assert(MinPriority <= priority && priority <= MaxPriority, "non-Java priority found");

  return priority;

}

void Thread::set_priority(Thread* thread, ThreadPriority priority) {

  trace("set priority", thread);

  debug_only(check_for_dangling_thread_pointer(thread);)

  // Can return an error!

  (void)os::set_priority(thread, priority);

}

void Thread::start(Thread* thread) {

  trace("start", thread);

  // Start is different from resume in that its safety is guaranteed by context or

  // being called from a Java method synchronized on the Thread object.

  if (!DisableStartThread) {

    if (thread->is_Java_thread()) {

      // Initialize the thread state to RUNNABLE before starting this thread.

      // Can not set it after the thread started because we do not know the

      // exact thread state at that time. It could be in MONITOR_WAIT or

      // in SLEEPING or some other state.

      java_lang_Thread::set_thread_status(((JavaThread*)thread)->threadObj(),

                                          java_lang_Thread::RUNNABLE);

    }

    os::start_thread(thread);

  }

}

// Enqueue a VM_Operation to do the job for us - sometime later

void Thread::send_async_exception(oop java_thread, oop java_throwable) {

  VM_ThreadStop* vm_stop = new VM_ThreadStop(java_thread, java_throwable);

  VMThread::execute(vm_stop);

}

//

// Check if an external suspend request has completed (or has been

// cancelled). Returns true if the thread is externally suspended and

// false otherwise.

//

// The bits parameter returns information about the code path through

// the routine. Useful for debugging:

//

// set in is_ext_suspend_completed():

// 0x00000001 - routine was entered

// 0x00000010 - routine return false at end

// 0x00000100 - thread exited (return false)

// 0x00000200 - suspend request cancelled (return false)

// 0x00000400 - thread suspended (return true)

// 0x00001000 - thread is in a suspend equivalent state (return true)

// 0x00002000 - thread is native and walkable (return true)

// 0x00004000 - thread is native_trans and walkable (needed retry)

//

// set in wait_for_ext_suspend_completion():

// 0x00010000 - routine was entered

// 0x00020000 - suspend request cancelled before loop (return false)

// 0x00040000 - thread suspended before loop (return true)

// 0x00080000 - suspend request cancelled in loop (return false)

// 0x00100000 - thread suspended in loop (return true)

// 0x00200000 - suspend not completed during retry loop (return false)

//

// Helper class for tracing suspend wait debug bits.

//

// 0x00000100 indicates that the target thread exited before it could

// self-suspend which is not a wait failure. 0x00000200, 0x00020000 and

// 0x00080000 each indicate a cancelled suspend request so they don't

// count as wait failures either.

#define DEBUG_FALSE_BITS (0x00000010 | 0x00200000)

class TraceSuspendDebugBits : public StackObj {

 private:

  JavaThread * jt;