/*

 * Copyright (c) 1997, 2018, 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 "jfr/support/jfrThreadId.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 "prims/privilegedStack.hpp"

#include "runtime/arguments.hpp"

#include "runtime/atomic.hpp"

#include "runtime/biasedLocking.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/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/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/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/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 "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/vmError.hpp"

#if INCLUDE_JVMCI

#include "jvmci/jvmciCompiler.hpp"

#include "jvmci/jvmciRuntime.hpp"

#include "logging/logHandle.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

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

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;

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

  _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 == 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. Note that the

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

  // BarrierSet::on_thread_create() for the main thread is therefore deferred

  // until it calls BarrierSet::set_barrier_set().

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

  if (barrier_set != NULL) {

    barrier_set->on_thread_create(this);

  }

}

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

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

}

Thread::~Thread() {

  JFR_ONLY(Jfr::on_thread_destruct(this);)

  // 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(_MutexEvent); _MutexEvent  = 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.

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

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

         !((JavaThread *) thread)->on_thread_list() ||

         SafepointSynchronize::is_at_safepoint() ||

         ThreadsSMRSupport::is_a_protected_JavaThread_with_lock((JavaThread *) thread),

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