/*

 * Copyright (c) 1997, 2016, 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/codeCache.hpp"

#include "code/codeCacheExtensions.hpp"

#include "code/scopeDesc.hpp"

#include "compiler/compileBroker.hpp"

#include "gc/shared/gcId.hpp"

#include "gc/shared/gcLocker.inline.hpp"

#include "gc/shared/workgroup.hpp"

#include "interpreter/interpreter.hpp"

#include "interpreter/linkResolver.hpp"

#include "interpreter/oopMapCache.hpp"

#include "jvmtifiles/jvmtiEnv.hpp"

#include "logging/log.hpp"

#include "logging/logConfiguration.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 "oops/verifyOopClosure.hpp"

#include "prims/jvm_misc.hpp"

#include "prims/jvmtiExport.hpp"

#include "prims/jvmtiThreadState.hpp"

#include "prims/privilegedStack.hpp"

#include "runtime/arguments.hpp"

#include "runtime/atomic.inline.hpp"

#include "runtime/biasedLocking.hpp"

#include "runtime/commandLineFlagConstraintList.hpp"

#include "runtime/commandLineFlagRangeList.hpp"

#include "runtime/deoptimization.hpp"

#include "runtime/fprofiler.hpp"

#include "runtime/frame.inline.hpp"

#include "runtime/globals.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/orderAccess.inline.hpp"

#include "runtime/osThread.hpp"

#include "runtime/safepoint.hpp"

#include "runtime/sharedRuntime.hpp"

#include "runtime/statSampler.hpp"

#include "runtime/stubRoutines.hpp"

#include "runtime/sweeper.hpp"

#include "runtime/task.hpp"

#include "runtime/thread.inline.hpp"

#include "runtime/threadCritical.hpp"

#include "runtime/vframe.hpp"

#include "runtime/vframeArray.hpp"

#include "runtime/vframe_hp.hpp"

#include "runtime/vmThread.hpp"

#include "runtime/vm_operations.hpp"

#include "runtime/vm_version.hpp"

#include "services/attachListener.hpp"

#include "services/management.hpp"

#include "services/memTracker.hpp"

#include "services/threadService.hpp"

#include "trace/traceMacros.hpp"

#include "trace/tracing.hpp"

#include "utilities/defaultStream.hpp"

#include "utilities/dtrace.hpp"

#include "utilities/events.hpp"

#include "utilities/macros.hpp"

#include "utilities/preserveException.hpp"

#if INCLUDE_ALL_GCS

#include "gc/cms/concurrentMarkSweepThread.hpp"

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

#include "gc/parallel/pcTasks.hpp"

#endif // INCLUDE_ALL_GCS

#if INCLUDE_JVMCI

#include "jvmci/jvmciCompiler.hpp"

#include "jvmci/jvmciRuntime.hpp"

#endif

#ifdef COMPILER1

#include "c1/c1_Compiler.hpp"

#endif

#ifdef COMPILER2

#include "opto/c2compiler.hpp"

#include "opto/idealGraphPrinter.hpp"

#endif

#if INCLUDE_RTM_OPT

#include "runtime/rtmLocking.hpp"

#endif

#ifdef DTRACE_ENABLED

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

  #define HOTSPOT_THREAD_PROBE_start HOTSPOT_THREAD_START

  #define HOTSPOT_THREAD_PROBE_stop HOTSPOT_THREAD_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()));           \

    }

#else //  ndef DTRACE_ENABLED

  #define DTRACE_THREAD_PROBE(probe, javathread)

#endif // ndef DTRACE_ENABLED

#ifndef USE_LIBRARY_BASED_TLS_ONLY

// Current thread is maintained as a thread-local variable

THREAD_LOCAL_DECL Thread* Thread::_thr_current = NULL;

#endif

// 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,

                      p2i(real_malloc_addr), p2i(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);

  } else {

    FreeHeap(p);

  }

}

// 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);

  DEBUG_ONLY(clear_suspendible_thread();)

  // 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;)

  _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,

                         Monitor::_safepoint_check_sometimes);

  _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_current() {

#ifndef USE_LIBRARY_BASED_TLS_ONLY

  assert(_thr_current == NULL, "Thread::current already initialized");

  _thr_current = this;

#endif

  assert(ThreadLocalStorage::thread() == NULL, "ThreadLocalStorage::thread already initialized");

  ThreadLocalStorage::set_thread(this);

  assert(Thread::current() == ThreadLocalStorage::thread(), "TLS mismatch!");

}

void Thread::clear_thread_current() {

  assert(Thread::current() == ThreadLocalStorage::thread(), "TLS mismatch!");

#ifndef USE_LIBRARY_BASED_TLS_ONLY

  _thr_current = NULL;

#endif

  ThreadLocalStorage::set_thread(NULL);

}

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);

  // Set stack limits after thread is initialized.

  if (is_Java_thread()) {

    ((JavaThread*) this)->set_stack_overflow_limit();

    ((JavaThread*) this)->set_reserved_stack_activation(stack_base());

  }

#if INCLUDE_NMT

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

  MemTracker::record_thread_stack(stack_end(), stack_size());

#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) {

    MemTracker::release_thread_stack(stack_end(), stack_size());

#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::current if thread is deleting itself.

  // Needed to ensure JNI correctly detects non-attached threads.

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

    clear_thread_current();

  }

  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

ThreadPriority Thread::get_priority(const Thread* const 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) {

  debug_only(check_for_dangling_thread_pointer(thread);)

  // Can return an error!

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

}

void Thread::start(Thread* 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;

  bool         is_wait;

  bool         called_by_wait;  // meaningful when !is_wait

  uint32_t *   bits;

 public:

  TraceSuspendDebugBits(JavaThread *_jt, bool _is_wait, bool _called_by_wait,

                        uint32_t *_bits) {

    jt             = _jt;

    is_wait        = _is_wait;

    called_by_wait = _called_by_wait;

    bits           = _bits;

  }

  ~TraceSuspendDebugBits() {

    if (!is_wait) {

#if 1

      // By default, don't trace bits for is_ext_suspend_completed() calls.

      // That trace is very chatty.

      return;

#else

      if (!called_by_wait) {

        // If tracing for is_ext_suspend_completed() is enabled, then only

        // trace calls to it from wait_for_ext_suspend_completion()

        return;

      }

#endif

    }

    if (AssertOnSuspendWaitFailure || TraceSuspendWaitFailures) {

      if (bits != NULL && (*bits & DEBUG_FALSE_BITS) != 0) {

        MutexLocker ml(Threads_lock);  // needed for get_thread_name()

        ResourceMark rm;

        tty->print_cr(

                      "Failed wait_for_ext_suspend_completion(thread=%s, debug_bits=%x)",

                      jt->get_thread_name(), *bits);

        guarantee(!AssertOnSuspendWaitFailure, "external suspend wait failed");