/*

 * 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.

 *

 */

#ifndef SHARE_VM_RUNTIME_THREAD_HPP

#define SHARE_VM_RUNTIME_THREAD_HPP

#include "jni.h"

#include "gc/shared/gcThreadLocalData.hpp"

#include "gc/shared/threadLocalAllocBuffer.hpp"

#include "memory/allocation.hpp"

#include "oops/oop.hpp"

#include "prims/jvmtiExport.hpp"

#include "runtime/frame.hpp"

#include "runtime/globals.hpp"

#include "runtime/handshake.hpp"

#include "runtime/javaFrameAnchor.hpp"

#include "runtime/jniHandles.hpp"

#include "runtime/mutexLocker.hpp"

#include "runtime/os.hpp"

#include "runtime/osThread.hpp"

#include "runtime/park.hpp"

#include "runtime/safepoint.hpp"

#include "runtime/stubRoutines.hpp"

#include "runtime/threadHeapSampler.hpp"

#include "runtime/threadLocalStorage.hpp"

#include "runtime/threadStatisticalInfo.hpp"

#include "runtime/unhandledOops.hpp"

#include "utilities/align.hpp"

#include "utilities/exceptions.hpp"

#include "utilities/macros.hpp"

#ifdef ZERO

# include "stack_zero.hpp"

#endif

#if INCLUDE_JFR

#include "jfr/support/jfrThreadExtension.hpp"

#endif

class SafeThreadsListPtr;

class ThreadSafepointState;

class ThreadsList;

class ThreadsSMRSupport;

class JvmtiThreadState;

class ThreadStatistics;

class ConcurrentLocksDump;

class ParkEvent;

class Parker;

class ciEnv;

class CompileThread;

class CompileLog;

class CompileTask;

class CompileQueue;

class CompilerCounters;

class vframeArray;

class DeoptResourceMark;

class jvmtiDeferredLocalVariableSet;

class GCTaskQueue;

class ThreadClosure;

class IdealGraphPrinter;

class Metadata;

template <class T, MEMFLAGS F> class ChunkedList;

typedef ChunkedList<Metadata*, mtInternal> MetadataOnStackBuffer;

DEBUG_ONLY(class ResourceMark;)

class WorkerThread;

// Class hierarchy

// - Thread

//   - JavaThread

//     - various subclasses eg CompilerThread, ServiceThread

//   - NonJavaThread

//     - NamedThread

//       - VMThread

//       - ConcurrentGCThread

//       - WorkerThread

//         - GangWorker

//         - GCTaskThread

//     - WatcherThread

//     - JfrThreadSampler

//

// All Thread subclasses must be either JavaThread or NonJavaThread.

// This means !t->is_Java_thread() iff t is a NonJavaThread, or t is

// a partially constructed/destroyed Thread.

class Thread: public ThreadShadow {

  friend class VMStructs;

  friend class JVMCIVMStructs;

 private:

#ifndef USE_LIBRARY_BASED_TLS_ONLY

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

  static THREAD_LOCAL_DECL Thread* _thr_current;

#endif

 private:

  // Thread local data area available to the GC. The internal

  // structure and contents of this data area is GC-specific.

  // Only GC and GC barrier code should access this data area.

  GCThreadLocalData _gc_data;

 public:

  static ByteSize gc_data_offset() {

    return byte_offset_of(Thread, _gc_data);

  }

  template <typename T> T* gc_data() {

    STATIC_ASSERT(sizeof(T) <= sizeof(_gc_data));

    return reinterpret_cast<T*>(&_gc_data);

  }

  // Exception handling

  // (Note: _pending_exception and friends are in ThreadShadow)

  //oop       _pending_exception;                // pending exception for current thread

  // const char* _exception_file;                   // file information for exception (debugging only)

  // int         _exception_line;                   // line information for exception (debugging only)

 protected:

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

  void*       _real_malloc_address;

  // JavaThread lifecycle support:

  friend class SafeThreadsListPtr;  // for _threads_list_ptr, cmpxchg_threads_hazard_ptr(), {dec_,inc_,}nested_threads_hazard_ptr_cnt(), {g,s}et_threads_hazard_ptr(), inc_nested_handle_cnt(), tag_hazard_ptr() access

  friend class ScanHazardPtrGatherProtectedThreadsClosure;  // for cmpxchg_threads_hazard_ptr(), get_threads_hazard_ptr(), is_hazard_ptr_tagged() access

  friend class ScanHazardPtrGatherThreadsListClosure;  // for get_threads_hazard_ptr(), untag_hazard_ptr() access

  friend class ScanHazardPtrPrintMatchingThreadsClosure;  // for get_threads_hazard_ptr(), is_hazard_ptr_tagged() access

  friend class ThreadsSMRSupport;  // for _nested_threads_hazard_ptr_cnt, _threads_hazard_ptr, _threads_list_ptr access

  ThreadsList* volatile _threads_hazard_ptr;

  SafeThreadsListPtr*   _threads_list_ptr;

  ThreadsList*          cmpxchg_threads_hazard_ptr(ThreadsList* exchange_value, ThreadsList* compare_value);

  ThreadsList*          get_threads_hazard_ptr();

  void                  set_threads_hazard_ptr(ThreadsList* new_list);

  static bool           is_hazard_ptr_tagged(ThreadsList* list) {

    return (intptr_t(list) & intptr_t(1)) == intptr_t(1);

  }

  static ThreadsList*   tag_hazard_ptr(ThreadsList* list) {

    return (ThreadsList*)(intptr_t(list) | intptr_t(1));

  }

  static ThreadsList*   untag_hazard_ptr(ThreadsList* list) {

    return (ThreadsList*)(intptr_t(list) & ~intptr_t(1));

  }

  // This field is enabled via -XX:+EnableThreadSMRStatistics:

  uint _nested_threads_hazard_ptr_cnt;

  void dec_nested_threads_hazard_ptr_cnt() {

    assert(_nested_threads_hazard_ptr_cnt != 0, "mismatched {dec,inc}_nested_threads_hazard_ptr_cnt()");

    _nested_threads_hazard_ptr_cnt--;

  }

  void inc_nested_threads_hazard_ptr_cnt() {

    _nested_threads_hazard_ptr_cnt++;

  }

  uint nested_threads_hazard_ptr_cnt() {

    return _nested_threads_hazard_ptr_cnt;

  }

 public:

  void* operator new(size_t size) throw() { return allocate(size, true); }

  void* operator new(size_t size, const std::nothrow_t& nothrow_constant) throw() {

    return allocate(size, false); }

  void  operator delete(void* p);

 protected:

  static void* allocate(size_t size, bool throw_excpt, MEMFLAGS flags = mtThread);

 private:

  // ***************************************************************

  // Suspend and resume support

  // ***************************************************************

  //

  // VM suspend/resume no longer exists - it was once used for various

  // things including safepoints but was deprecated and finally removed

  // in Java 7. Because VM suspension was considered "internal" Java-level

  // suspension was considered "external", and this legacy naming scheme

  // remains.

  //

  // External suspend/resume requests come from JVM_SuspendThread,

  // JVM_ResumeThread, JVMTI SuspendThread, and finally JVMTI

  // ResumeThread. External

  // suspend requests cause _external_suspend to be set and external

  // resume requests cause _external_suspend to be cleared.

  // External suspend requests do not nest on top of other external

  // suspend requests. The higher level APIs reject suspend requests

  // for already suspended threads.

  //

  // The external_suspend

  // flag is checked by has_special_runtime_exit_condition() and java thread

  // will self-suspend when handle_special_runtime_exit_condition() is

  // called. Most uses of the _thread_blocked state in JavaThreads are

  // considered the same as being externally suspended; if the blocking

  // condition lifts, the JavaThread will self-suspend. Other places

  // where VM checks for external_suspend include:

  //   + mutex granting (do not enter monitors when thread is suspended)

  //   + state transitions from _thread_in_native

  //

  // In general, java_suspend() does not wait for an external suspend

  // request to complete. When it returns, the only guarantee is that

  // the _external_suspend field is true.

  //

  // wait_for_ext_suspend_completion() is used to wait for an external

  // suspend request to complete. External suspend requests are usually

  // followed by some other interface call that requires the thread to

  // be quiescent, e.g., GetCallTrace(). By moving the "wait time" into

  // the interface that requires quiescence, we give the JavaThread a

  // chance to self-suspend before we need it to be quiescent. This

  // improves overall suspend/query performance.

  //

  // _suspend_flags controls the behavior of java_ suspend/resume.

  // It must be set under the protection of SR_lock. Read from the flag is

  // OK without SR_lock as long as the value is only used as a hint.

  // (e.g., check _external_suspend first without lock and then recheck

  // inside SR_lock and finish the suspension)

  //

  // _suspend_flags is also overloaded for other "special conditions" so

  // that a single check indicates whether any special action is needed

  // eg. for async exceptions.

  // -------------------------------------------------------------------

  // Notes:

  // 1. The suspend/resume logic no longer uses ThreadState in OSThread

  // but we still update its value to keep other part of the system (mainly

  // JVMTI) happy. ThreadState is legacy code (see notes in

  // osThread.hpp).

  //

  // 2. It would be more natural if set_external_suspend() is private and

  // part of java_suspend(), but that probably would affect the suspend/query

  // performance. Need more investigation on this.

  // suspend/resume lock: used for self-suspend

  Monitor* _SR_lock;

 protected:

  enum SuspendFlags {

    // NOTE: avoid using the sign-bit as cc generates different test code

    //       when the sign-bit is used, and sometimes incorrectly - see CR 6398077

    _external_suspend       = 0x20000000U, // thread is asked to self suspend

    _ext_suspended          = 0x40000000U, // thread has self-suspended

    _deopt_suspend          = 0x10000000U, // thread needs to self suspend for deopt

    _has_async_exception    = 0x00000001U, // there is a pending async exception

    _critical_native_unlock = 0x00000002U, // Must call back to unlock JNI critical lock

    _trace_flag             = 0x00000004U  // call tracing backend

  };

  // various suspension related flags - atomically updated

  // overloaded for async exception checking in check_special_condition_for_native_trans.

  volatile uint32_t _suspend_flags;

 private:

  int _num_nested_signal;

  DEBUG_ONLY(bool _suspendible_thread;)

 public:

  void enter_signal_handler() { _num_nested_signal++; }

  void leave_signal_handler() { _num_nested_signal--; }

  bool is_inside_signal_handler() const { return _num_nested_signal > 0; }

#ifdef ASSERT

  void set_suspendible_thread() {

    _suspendible_thread = true;

  }

  void clear_suspendible_thread() {

    _suspendible_thread = false;

  }

  bool is_suspendible_thread() { return _suspendible_thread; }

#endif

 private:

  // Active_handles points to a block of handles

  JNIHandleBlock* _active_handles;

  // One-element thread local free list

  JNIHandleBlock* _free_handle_block;

  // Point to the last handle mark

  HandleMark* _last_handle_mark;

  // The parity of the last strong_roots iteration in which this thread was

  // claimed as a task.

  int _oops_do_parity;

  // Support for GlobalCounter

 private:

  volatile uintx _rcu_counter;

 public:

  volatile uintx* get_rcu_counter() {

    return &_rcu_counter;

  }

 public:

  void set_last_handle_mark(HandleMark* mark)   { _last_handle_mark = mark; }

  HandleMark* last_handle_mark() const          { return _last_handle_mark; }

 private:

  // debug support for checking if code does allow safepoints or not

  // GC points in the VM can happen because of allocation, invoking a VM operation, or blocking on

  // mutex, or blocking on an object synchronizer (Java locking).

  // If !allow_safepoint(), then an assertion failure will happen in any of the above cases

  // If !allow_allocation(), then an assertion failure will happen during allocation

  // (Hence, !allow_safepoint() => !allow_allocation()).

  //

  // The two classes NoSafepointVerifier and No_Allocation_Verifier are used to set these counters.

  //

  NOT_PRODUCT(int _allow_safepoint_count;)      // If 0, thread allow a safepoint to happen

  debug_only(int _allow_allocation_count;)     // If 0, the thread is allowed to allocate oops.

  // Used by SkipGCALot class.

  NOT_PRODUCT(bool _skip_gcalot;)               // Should we elide gc-a-lot?

  friend class NoAllocVerifier;

  friend class NoSafepointVerifier;

  friend class PauseNoSafepointVerifier;

  friend class GCLocker;

  volatile void* _polling_page;                 // Thread local polling page

  ThreadLocalAllocBuffer _tlab;                 // Thread-local eden

  jlong _allocated_bytes;                       // Cumulative number of bytes allocated on

                                                // the Java heap

  ThreadHeapSampler _heap_sampler;              // For use when sampling the memory.

  ThreadStatisticalInfo _statistical_info;      // Statistics about the thread

  JFR_ONLY(DEFINE_THREAD_LOCAL_FIELD_JFR;)      // Thread-local data for jfr

  int   _vm_operation_started_count;            // VM_Operation support

  int   _vm_operation_completed_count;          // VM_Operation support

  ObjectMonitor* _current_pending_monitor;      // ObjectMonitor this thread

                                                // is waiting to lock

  bool _current_pending_monitor_is_from_java;   // locking is from Java code

  // ObjectMonitor on which this thread called Object.wait()

  ObjectMonitor* _current_waiting_monitor;

  // Private thread-local objectmonitor list - a simple cache organized as a SLL.

 public:

  ObjectMonitor* omFreeList;

  int omFreeCount;                              // length of omFreeList

  int omFreeProvision;                          // reload chunk size

  ObjectMonitor* omInUseList;                   // SLL to track monitors in circulation

  int omInUseCount;                             // length of omInUseList

#ifdef ASSERT

 private:

  bool _visited_for_critical_count;

 public:

  void set_visited_for_critical_count(bool z) { _visited_for_critical_count = z; }

  bool was_visited_for_critical_count() const   { return _visited_for_critical_count; }

#endif

 public:

  enum {

    is_definitely_current_thread = true

  };

  // Constructor

  Thread();

  virtual ~Thread() = 0;        // Thread is abstract.

  // Manage Thread::current()

  void initialize_thread_current();

  void clear_thread_current(); // TLS cleanup needed before threads terminate

 public:

  // thread entry point

  virtual void run();

  // Testers

  virtual bool is_VM_thread()       const            { return false; }

  virtual bool is_Java_thread()     const            { return false; }

  virtual bool is_Compiler_thread() const            { return false; }

  virtual bool is_Code_cache_sweeper_thread() const  { return false; }

  virtual bool is_hidden_from_external_view() const  { return false; }

  virtual bool is_jvmti_agent_thread() const         { return false; }

  // True iff the thread can perform GC operations at a safepoint.

  // Generally will be true only of VM thread and parallel GC WorkGang

  // threads.

  virtual bool is_GC_task_thread() const             { return false; }

  virtual bool is_Watcher_thread() const             { return false; }

  virtual bool is_ConcurrentGC_thread() const        { return false; }

  virtual bool is_Named_thread() const               { return false; }

  virtual bool is_Worker_thread() const              { return false; }

  // Can this thread make Java upcalls

  virtual bool can_call_java() const                 { return false; }

  // Casts

  virtual WorkerThread* as_Worker_thread() const     { return NULL; }

  virtual char* name() const { return (char*)"Unknown thread"; }

  // Returns the current thread (ASSERTS if NULL)

  static inline Thread* current();

  // Returns the current thread, or NULL if not attached

  static inline Thread* current_or_null();

  // Returns the current thread, or NULL if not attached, and is

  // safe for use from signal-handlers

  static inline Thread* current_or_null_safe();

  // Common thread operations

#ifdef ASSERT

  static void check_for_dangling_thread_pointer(Thread *thread);

#endif

  static void set_priority(Thread* thread, ThreadPriority priority);

  static ThreadPriority get_priority(const Thread* const thread);

  static void start(Thread* thread);

  static void interrupt(Thread* thr);

  static bool is_interrupted(Thread* thr, bool clear_interrupted);

  void set_native_thread_name(const char *name) {

    assert(Thread::current() == this, "set_native_thread_name can only be called on the current thread");

    os::set_native_thread_name(name);

  }

  ObjectMonitor** omInUseList_addr()             { return (ObjectMonitor **)&omInUseList; }

  Monitor* SR_lock() const                       { return _SR_lock; }

  bool has_async_exception() const { return (_suspend_flags & _has_async_exception) != 0; }

  inline void set_suspend_flag(SuspendFlags f);

  inline void clear_suspend_flag(SuspendFlags f);

  inline void set_has_async_exception();

  inline void clear_has_async_exception();

  bool do_critical_native_unlock() const { return (_suspend_flags & _critical_native_unlock) != 0; }

  inline void set_critical_native_unlock();

  inline void clear_critical_native_unlock();

  inline void set_trace_flag();

  inline void clear_trace_flag();

  // Support for Unhandled Oop detection

  // Add the field for both, fastdebug and debug, builds to keep

  // Thread's fields layout the same.

  // Note: CHECK_UNHANDLED_OOPS is defined only for fastdebug build.

#ifdef CHECK_UNHANDLED_OOPS

 private:

  UnhandledOops* _unhandled_oops;

#elif defined(ASSERT)

 private:

  void* _unhandled_oops;

#endif

#ifdef CHECK_UNHANDLED_OOPS

 public:

  UnhandledOops* unhandled_oops() { return _unhandled_oops; }

  // Mark oop safe for gc.  It may be stack allocated but won't move.

  void allow_unhandled_oop(oop *op) {

    if (CheckUnhandledOops) unhandled_oops()->allow_unhandled_oop(op);

  }

  // Clear oops at safepoint so crashes point to unhandled oop violator

  void clear_unhandled_oops() {

    if (CheckUnhandledOops) unhandled_oops()->clear_unhandled_oops();

  }

#endif // CHECK_UNHANDLED_OOPS

 public:

#ifndef PRODUCT

  bool skip_gcalot()           { return _skip_gcalot; }

  void set_skip_gcalot(bool v) { _skip_gcalot = v;    }

#endif

  // Installs a pending exception to be inserted later

  static void send_async_exception(oop thread_oop, oop java_throwable);

  // Resource area

  ResourceArea* resource_area() const            { return _resource_area; }

  void set_resource_area(ResourceArea* area)     { _resource_area = area; }

  OSThread* osthread() const                     { return _osthread;   }