/*

 * Copyright (c) 1997, 2019, 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 "jvm.h"

#include "classfile/classLoader.hpp"

#include "classfile/javaClasses.hpp"

#include "classfile/moduleEntry.hpp"

#include "classfile/systemDictionary.hpp"

#include "classfile/vmSymbols.hpp"

#include "code/codeCache.hpp"

#include "code/scopeDesc.hpp"

#include "compiler/compileBroker.hpp"

#include "compiler/compileTask.hpp"

#include "gc/shared/barrierSet.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 "jfr/jfrEvents.hpp"

#include "jvmtifiles/jvmtiEnv.hpp"

#include "logging/log.hpp"

#include "logging/logConfiguration.hpp"

#include "logging/logStream.hpp"

#include "memory/allocation.inline.hpp"

#include "memory/metaspaceShared.hpp"

#include "memory/oopFactory.hpp"

#include "memory/resourceArea.hpp"

#include "memory/universe.hpp"

#include "oops/access.inline.hpp"

#include "oops/instanceKlass.hpp"

#include "oops/objArrayOop.hpp"

#include "oops/oop.inline.hpp"

#include "oops/symbol.hpp"

#include "oops/typeArrayOop.inline.hpp"

#include "oops/verifyOopClosure.hpp"

#include "prims/jvm_misc.hpp"

#include "prims/jvmtiExport.hpp"

#include "prims/jvmtiThreadState.hpp"

#include "runtime/arguments.hpp"

#include "runtime/atomic.hpp"

#include "runtime/biasedLocking.hpp"

#include "runtime/fieldDescriptor.inline.hpp"

#include "runtime/flags/jvmFlagConstraintList.hpp"

#include "runtime/flags/jvmFlagRangeList.hpp"

#include "runtime/flags/jvmFlagWriteableList.hpp"

#include "runtime/deoptimization.hpp"

#include "runtime/frame.inline.hpp"

#include "runtime/handles.inline.hpp"

#include "runtime/handshake.hpp"

#include "runtime/init.hpp"

#include "runtime/interfaceSupport.inline.hpp"

#include "runtime/java.hpp"

#include "runtime/javaCalls.hpp"

#include "runtime/jniHandles.inline.hpp"

#include "runtime/jniPeriodicChecker.hpp"

#include "runtime/memprofiler.hpp"

#include "runtime/mutexLocker.hpp"

#include "runtime/objectMonitor.hpp"

#include "runtime/orderAccess.hpp"

#include "runtime/osThread.hpp"

#include "runtime/prefetch.inline.hpp"

#include "runtime/safepoint.hpp"

#include "runtime/safepointMechanism.inline.hpp"

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

#include "runtime/threadStatisticalInfo.hpp"

#include "runtime/timer.hpp"

#include "runtime/timerTrace.hpp"

#include "runtime/vframe.inline.hpp"

#include "runtime/vframeArray.hpp"

#include "runtime/vframe_hp.hpp"

#include "runtime/vmThread.hpp"

#include "runtime/vmOperations.hpp"

#include "runtime/vm_version.hpp"

#include "services/attachListener.hpp"

#include "services/management.hpp"

#include "services/memTracker.hpp"

#include "services/threadService.hpp"

#include "utilities/align.hpp"

#include "utilities/copy.hpp"

#include "utilities/defaultStream.hpp"

#include "utilities/dtrace.hpp"

#include "utilities/events.hpp"

#include "utilities/macros.hpp"

#include "utilities/preserveException.hpp"

#include "utilities/singleWriterSynchronizer.hpp"

#include "utilities/vmError.hpp"

#if INCLUDE_JVMCI

#include "jvmci/jvmci.hpp"

#include "jvmci/jvmciEnv.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

#if INCLUDE_JFR

#include "jfr/jfr.hpp"

#endif

// Initialization after module runtime initialization

void universe_post_module_init();  // must happen after call_initPhase2

#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

// ======= 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     = align_up(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 (aligned_addr != real_malloc_addr) {

      log_info(biasedlocking)("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) {

    FreeHeap(((Thread*) p)->_real_malloc_address);

  } else {

    FreeHeap(p);

  }

}

void JavaThread::smr_delete() {

  if (_on_thread_list) {

    ThreadsSMRSupport::smr_delete(this);

  } else {

    delete this;

  }

}

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

// JavaThread

DEBUG_ONLY(Thread* Thread::_starting_thread = NULL;)

Thread::Thread() {

  DEBUG_ONLY(_run_state = PRE_CALL_RUN;)

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

  DEBUG_ONLY(_missed_ic_stub_refill_verifier = NULL);

  // Initial value of zero ==> never claimed.

  _threads_do_token = 0;

  _threads_hazard_ptr = NULL;

  _threads_list_ptr = NULL;

  _nested_threads_hazard_ptr_cnt = 0;

  _rcu_counter = 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;

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

  _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 == align_up(_real_malloc_address, (int)markOopDesc::biased_lock_alignment),

           "bug in forced alignment of thread objects");

  }

#endif // ASSERT

  // Notify the barrier set that a thread is being created. The initial

  // thread is created before the barrier set is available.  The call to

  // BarrierSet::on_thread_create() for this thread is therefore deferred

  // to BarrierSet::set_barrier_set().

  BarrierSet* const barrier_set = BarrierSet::barrier_set();

  if (barrier_set != NULL) {

    barrier_set->on_thread_create(this);

  } else {

    // Only the main thread should be created before the barrier set

    // and that happens just before Thread::current is set. No other thread

    // can attach as the VM is not created yet, so they can't execute this code.

    // If the main thread creates other threads before the barrier set that is an error.

    assert(Thread::current_or_null() == NULL, "creating thread before barrier set");

  }

}

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

  // Note: at this point, Thread object is not yet initialized. Do not rely on

  // any members being initialized. Do not rely on Thread::current() being set.

  // If possible, refrain from doing anything which may crash or assert since

  // quite probably those crash dumps will be useless.

  set_stack_base(os::current_stack_base());

  set_stack_size(os::current_stack_size());

#ifdef SOLARIS

  if (os::is_primordial_thread()) {

    os::Solaris::correct_stack_boundaries_for_primordial_thread(this);

  }

#endif

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

void Thread::register_thread_stack_with_NMT() {

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

}

#endif // INCLUDE_NMT

void Thread::call_run() {

  DEBUG_ONLY(_run_state = CALL_RUN;)

  // At this point, Thread object should be fully initialized and

  // Thread::current() should be set.

  assert(Thread::current_or_null() != NULL, "current thread is unset");

  assert(Thread::current_or_null() == this, "current thread is wrong");

  // Perform common initialization actions

  register_thread_stack_with_NMT();

  JFR_ONLY(Jfr::on_thread_start(this);)

  log_debug(os, thread)("Thread " UINTX_FORMAT " stack dimensions: "

    PTR_FORMAT "-" PTR_FORMAT " (" SIZE_FORMAT "k).",

    os::current_thread_id(), p2i(stack_base() - stack_size()),

    p2i(stack_base()), stack_size()/1024);

  // Perform <ChildClass> initialization actions

  DEBUG_ONLY(_run_state = PRE_RUN;)

  this->pre_run();

  // Invoke <ChildClass>::run()

  DEBUG_ONLY(_run_state = RUN;)

  this->run();

  // Returned from <ChildClass>::run(). Thread finished.

  // Perform common tear-down actions

  assert(Thread::current_or_null() != NULL, "current thread is unset");

  assert(Thread::current_or_null() == this, "current thread is wrong");

  // Perform <ChildClass> tear-down actions

  DEBUG_ONLY(_run_state = POST_RUN;)

  this->post_run();

  // Note: at this point the thread object may already have deleted itself,

  // so from here on do not dereference *this*. Not all thread types currently

  // delete themselves when they terminate. But no thread should ever be deleted

  // asynchronously with respect to its termination - that is what _run_state can

  // be used to check.

  assert(Thread::current_or_null() == NULL, "current thread still present");

}

Thread::~Thread() {

  // Attached threads will remain in PRE_CALL_RUN, as will threads that don't actually

  // get started due to errors etc. Any active thread should at least reach post_run

  // before it is deleted (usually in post_run()).

  assert(_run_state == PRE_CALL_RUN ||

         _run_state == POST_RUN, "Active Thread deleted before post_run(): "

         "_run_state=%d", (int)_run_state);

  // Notify the barrier set that a thread is being destroyed. Note that a barrier

  // set might not be available if we encountered errors during bootstrapping.

  BarrierSet* const barrier_set = BarrierSet::barrier_set();

  if (barrier_set != NULL) {

    barrier_set->on_thread_destroy(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(_MuxEvent); _MuxEvent    = NULL;

  delete handle_area();

  delete metadata_handles();

  // SR_handler uses this as a termination indicator -

  // needs to happen before os::free_thread()

  delete _SR_lock;

  _SR_lock = NULL;

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

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

  // Clear Thread::current if thread is deleting itself and it has not

  // already been done. This must be done before the memory is deallocated.

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

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

    Thread::clear_thread_current();

  }

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

}

#ifdef ASSERT

// A JavaThread is considered "dangling" if it is not the current

// thread, has been added the Threads list, the system is not at a

// safepoint and the Thread is not "protected".

//

void Thread::check_for_dangling_thread_pointer(Thread *thread) {

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