/*

 * Copyright (c) 2003, 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 "classfile/systemDictionary.hpp"

#include "memory/allocation.hpp"

#include "memory/heapInspection.hpp"

#include "memory/oopFactory.hpp"

#include "memory/resourceArea.hpp"

#include "oops/instanceKlass.hpp"

#include "oops/objArrayOop.inline.hpp"

#include "oops/oop.inline.hpp"

#include "runtime/atomic.hpp"

#include "runtime/handles.inline.hpp"

#include "runtime/init.hpp"

#include "runtime/objectMonitor.inline.hpp"

#include "runtime/thread.inline.hpp"

#include "runtime/threadSMR.inline.hpp"

#include "runtime/vframe.hpp"

#include "runtime/vmThread.hpp"

#include "runtime/vmOperations.hpp"

#include "services/threadService.hpp"

// TODO: we need to define a naming convention for perf counters

// to distinguish counters for:

//   - standard JSR174 use

//   - Hotspot extension (public and committed)

//   - Hotspot extension (private/internal and uncommitted)

// Default is disabled.

bool ThreadService::_thread_monitoring_contention_enabled = false;

bool ThreadService::_thread_cpu_time_enabled = false;

bool ThreadService::_thread_allocated_memory_enabled = false;

PerfCounter*  ThreadService::_total_threads_count = NULL;

PerfVariable* ThreadService::_live_threads_count = NULL;

PerfVariable* ThreadService::_peak_threads_count = NULL;

PerfVariable* ThreadService::_daemon_threads_count = NULL;

volatile int ThreadService::_atomic_threads_count = 0;

volatile int ThreadService::_atomic_daemon_threads_count = 0;

ThreadDumpResult* ThreadService::_threaddump_list = NULL;

static const int INITIAL_ARRAY_SIZE = 10;

void ThreadService::init() {

  EXCEPTION_MARK;

  // These counters are for java.lang.management API support.

  // They are created even if -XX:-UsePerfData is set and in

  // that case, they will be allocated on C heap.

  _total_threads_count =

                PerfDataManager::create_counter(JAVA_THREADS, "started",

                                                PerfData::U_Events, CHECK);

  _live_threads_count =

                PerfDataManager::create_variable(JAVA_THREADS, "live",

                                                 PerfData::U_None, CHECK);

  _peak_threads_count =

                PerfDataManager::create_variable(JAVA_THREADS, "livePeak",

                                                 PerfData::U_None, CHECK);

  _daemon_threads_count =

                PerfDataManager::create_variable(JAVA_THREADS, "daemon",

                                                 PerfData::U_None, CHECK);

  if (os::is_thread_cpu_time_supported()) {

    _thread_cpu_time_enabled = true;

  }

  _thread_allocated_memory_enabled = true; // Always on, so enable it

}

void ThreadService::reset_peak_thread_count() {

  // Acquire the lock to update the peak thread count

  // to synchronize with thread addition and removal.

  MutexLocker mu(Threads_lock);

  _peak_threads_count->set_value(get_live_thread_count());

}

static bool is_hidden_thread(JavaThread *thread) {

  // hide VM internal or JVMTI agent threads

  return thread->is_hidden_from_external_view() || thread->is_jvmti_agent_thread();

}

void ThreadService::add_thread(JavaThread* thread, bool daemon) {

  assert(Threads_lock->owned_by_self(), "must have threads lock");

  // Do not count hidden threads

  if (is_hidden_thread(thread)) {

    return;

  }

  _total_threads_count->inc();

  _live_threads_count->inc();

  Atomic::inc(&_atomic_threads_count);

  int count = _atomic_threads_count;

  if (count > _peak_threads_count->get_value()) {

    _peak_threads_count->set_value(count);

  }

  if (daemon) {

    _daemon_threads_count->inc();

    Atomic::inc(&_atomic_daemon_threads_count);

  }

}

void ThreadService::decrement_thread_counts(JavaThread* jt, bool daemon) {

  Atomic::dec(&_atomic_threads_count);

  if (daemon) {

    Atomic::dec(&_atomic_daemon_threads_count);

  }

}

void ThreadService::remove_thread(JavaThread* thread, bool daemon) {

  assert(Threads_lock->owned_by_self(), "must have threads lock");

  // Do not count hidden threads

  if (is_hidden_thread(thread)) {

    return;

  }

  assert(!thread->is_terminated(), "must not be terminated");

  if (!thread->is_exiting()) {

    // JavaThread::exit() skipped calling current_thread_exiting()

    decrement_thread_counts(thread, daemon);

  }

  int daemon_count = _atomic_daemon_threads_count;

  int count = _atomic_threads_count;

  // Counts are incremented at the same time, but atomic counts are

  // decremented earlier than perf counts.

  assert(_live_threads_count->get_value() > count,

    "thread count mismatch %d : %d",

    (int)_live_threads_count->get_value(), count);

  _live_threads_count->dec(1);

  if (daemon) {

    assert(_daemon_threads_count->get_value() > daemon_count,

      "thread count mismatch %d : %d",

      (int)_daemon_threads_count->get_value(), daemon_count);

    _daemon_threads_count->dec(1);

  }

  // Counts are incremented at the same time, but atomic counts are

  // decremented earlier than perf counts.

  assert(_daemon_threads_count->get_value() >= daemon_count,

    "thread count mismatch %d : %d",

    (int)_daemon_threads_count->get_value(), daemon_count);

  assert(_live_threads_count->get_value() >= count,

    "thread count mismatch %d : %d",

    (int)_live_threads_count->get_value(), count);

  assert(_live_threads_count->get_value() > 0 ||

    (_live_threads_count->get_value() == 0 && count == 0 &&

    _daemon_threads_count->get_value() == 0 && daemon_count == 0),

    "thread counts should reach 0 at the same time, live %d,%d daemon %d,%d",

    (int)_live_threads_count->get_value(), count,

    (int)_daemon_threads_count->get_value(), daemon_count);

  assert(_daemon_threads_count->get_value() > 0 ||

    (_daemon_threads_count->get_value() == 0 && daemon_count == 0),

    "thread counts should reach 0 at the same time, daemon %d,%d",

    (int)_daemon_threads_count->get_value(), daemon_count);

}

void ThreadService::current_thread_exiting(JavaThread* jt, bool daemon) {

  // Do not count hidden threads

  if (is_hidden_thread(jt)) {

    return;

  }

  assert(jt == JavaThread::current(), "Called by current thread");

  assert(!jt->is_terminated() && jt->is_exiting(), "must be exiting");

  decrement_thread_counts(jt, daemon);

}

// FIXME: JVMTI should call this function

Handle ThreadService::get_current_contended_monitor(JavaThread* thread) {

  assert(thread != NULL, "should be non-NULL");

  debug_only(Thread::check_for_dangling_thread_pointer(thread);)

  ObjectMonitor *wait_obj = thread->current_waiting_monitor();

  oop obj = NULL;

  if (wait_obj != NULL) {

    // thread is doing an Object.wait() call

    obj = (oop) wait_obj->object();

    assert(obj != NULL, "Object.wait() should have an object");

  } else {

    ObjectMonitor *enter_obj = thread->current_pending_monitor();

    if (enter_obj != NULL) {

      // thread is trying to enter() or raw_enter() an ObjectMonitor.

      obj = (oop) enter_obj->object();

    }

    // If obj == NULL, then ObjectMonitor is raw which doesn't count.

  }

  Handle h(Thread::current(), obj);

  return h;

}

bool ThreadService::set_thread_monitoring_contention(bool flag) {

  MutexLocker m(Management_lock);

  bool prev = _thread_monitoring_contention_enabled;

  _thread_monitoring_contention_enabled = flag;

  return prev;

}

bool ThreadService::set_thread_cpu_time_enabled(bool flag) {

  MutexLocker m(Management_lock);

  bool prev = _thread_cpu_time_enabled;

  _thread_cpu_time_enabled = flag;

  return prev;

}

bool ThreadService::set_thread_allocated_memory_enabled(bool flag) {

  MutexLocker m(Management_lock);

  bool prev = _thread_allocated_memory_enabled;

  _thread_allocated_memory_enabled = flag;

  return prev;

}

// GC support

void ThreadService::oops_do(OopClosure* f) {

  for (ThreadDumpResult* dump = _threaddump_list; dump != NULL; dump = dump->next()) {

    dump->oops_do(f);

  }

}

void ThreadService::metadata_do(void f(Metadata*)) {

  for (ThreadDumpResult* dump = _threaddump_list; dump != NULL; dump = dump->next()) {

    dump->metadata_do(f);

  }

}

void ThreadService::add_thread_dump(ThreadDumpResult* dump) {

  MutexLocker ml(Management_lock);

  if (_threaddump_list == NULL) {

    _threaddump_list = dump;

  } else {

    dump->set_next(_threaddump_list);

    _threaddump_list = dump;

  }

}

void ThreadService::remove_thread_dump(ThreadDumpResult* dump) {

  MutexLocker ml(Management_lock);

  ThreadDumpResult* prev = NULL;

  bool found = false;

  for (ThreadDumpResult* d = _threaddump_list; d != NULL; prev = d, d = d->next()) {

    if (d == dump) {

      if (prev == NULL) {

        _threaddump_list = dump->next();

      } else {

        prev->set_next(dump->next());

      }

      found = true;

      break;

    }

  }

  assert(found, "The threaddump result to be removed must exist.");

}

// Dump stack trace of threads specified in the given threads array.

// Returns StackTraceElement[][] each element is the stack trace of a thread in

// the corresponding entry in the given threads array

Handle ThreadService::dump_stack_traces(GrowableArray<instanceHandle>* threads,

                                        int num_threads,

                                        TRAPS) {

  assert(num_threads > 0, "just checking");

  ThreadDumpResult dump_result;

  VM_ThreadDump op(&dump_result,

                   threads,

                   num_threads,

                   -1,    /* entire stack */

                   false, /* with locked monitors */

                   false  /* with locked synchronizers */);

  VMThread::execute(&op);

  // Allocate the resulting StackTraceElement[][] object

  ResourceMark rm(THREAD);

  Klass* k = SystemDictionary::resolve_or_fail(vmSymbols::java_lang_StackTraceElement_array(), true, CHECK_NH);

  ObjArrayKlass* ik = ObjArrayKlass::cast(k);

  objArrayOop r = oopFactory::new_objArray(ik, num_threads, CHECK_NH);

  objArrayHandle result_obj(THREAD, r);

  int num_snapshots = dump_result.num_snapshots();

  assert(num_snapshots == num_threads, "Must have num_threads thread snapshots");

  assert(num_snapshots == 0 || dump_result.t_list_has_been_set(), "ThreadsList must have been set if we have a snapshot");

  int i = 0;

  for (ThreadSnapshot* ts = dump_result.snapshots(); ts != NULL; i++, ts = ts->next()) {

    ThreadStackTrace* stacktrace = ts->get_stack_trace();

    if (stacktrace == NULL) {

      // No stack trace

      result_obj->obj_at_put(i, NULL);

    } else {

      // Construct an array of java/lang/StackTraceElement object

      Handle backtrace_h = stacktrace->allocate_fill_stack_trace_element_array(CHECK_NH);

      result_obj->obj_at_put(i, backtrace_h());

    }

  }

  return result_obj;

}

void ThreadService::reset_contention_count_stat(JavaThread* thread) {

  ThreadStatistics* stat = thread->get_thread_stat();

  if (stat != NULL) {

    stat->reset_count_stat();

  }

}

void ThreadService::reset_contention_time_stat(JavaThread* thread) {

  ThreadStatistics* stat = thread->get_thread_stat();

  if (stat != NULL) {

    stat->reset_time_stat();

  }

}

// Find deadlocks involving object monitors and concurrent locks if concurrent_locks is true

DeadlockCycle* ThreadService::find_deadlocks_at_safepoint(ThreadsList * t_list, bool concurrent_locks) {

  assert(SafepointSynchronize::is_at_safepoint(), "must be at safepoint");

  // This code was modified from the original Threads::find_deadlocks code.

  int globalDfn = 0, thisDfn;

  ObjectMonitor* waitingToLockMonitor = NULL;

  oop waitingToLockBlocker = NULL;

  bool blocked_on_monitor = false;

  JavaThread *currentThread, *previousThread;

  int num_deadlocks = 0;

  // Initialize the depth-first-number for each JavaThread.

  JavaThreadIterator jti(t_list);

  for (JavaThread* jt = jti.first(); jt != NULL; jt = jti.next()) {

    jt->set_depth_first_number(-1);

  }

  DeadlockCycle* deadlocks = NULL;

  DeadlockCycle* last = NULL;

  DeadlockCycle* cycle = new DeadlockCycle();

  for (JavaThread* jt = jti.first(); jt != NULL; jt = jti.next()) {

    if (jt->depth_first_number() >= 0) {

      // this thread was already visited

      continue;

    }

    thisDfn = globalDfn;

    jt->set_depth_first_number(globalDfn++);

    previousThread = jt;

    currentThread = jt;

    cycle->reset();

    // When there is a deadlock, all the monitors involved in the dependency

    // cycle must be contended and heavyweight. So we only care about the

    // heavyweight monitor a thread is waiting to lock.

    waitingToLockMonitor = (ObjectMonitor*)jt->current_pending_monitor();

    if (concurrent_locks) {

      waitingToLockBlocker = jt->current_park_blocker();

    }

    while (waitingToLockMonitor != NULL || waitingToLockBlocker != NULL) {

      cycle->add_thread(currentThread);

      if (waitingToLockMonitor != NULL) {

        address currentOwner = (address)waitingToLockMonitor->owner();

        if (currentOwner != NULL) {

          currentThread = Threads::owning_thread_from_monitor_owner(t_list,

                                                                    currentOwner);

          if (currentThread == NULL) {

            // This function is called at a safepoint so the JavaThread

            // that owns waitingToLockMonitor should be findable, but

            // if it is not findable, then the previous currentThread is

            // blocked permanently. We record this as a deadlock.

            num_deadlocks++;

            cycle->set_deadlock(true);

            // add this cycle to the deadlocks list

            if (deadlocks == NULL) {

              deadlocks = cycle;

            } else {

              last->set_next(cycle);

            }

            last = cycle;

            cycle = new DeadlockCycle();

            break;

          }

        }

      } else {

        if (concurrent_locks) {

          if (waitingToLockBlocker->is_a(SystemDictionary::java_util_concurrent_locks_AbstractOwnableSynchronizer_klass())) {

            oop threadObj = java_util_concurrent_locks_AbstractOwnableSynchronizer::get_owner_threadObj(waitingToLockBlocker);

            // This JavaThread (if there is one) is protected by the

            // ThreadsListSetter in VM_FindDeadlocks::doit().

            currentThread = threadObj != NULL ? java_lang_Thread::thread(threadObj) : NULL;

          } else {

            currentThread = NULL;

          }

        }

      }

      if (currentThread == NULL) {

        // No dependency on another thread

        break;

      }

      if (currentThread->depth_first_number() < 0) {

        // First visit to this thread

        currentThread->set_depth_first_number(globalDfn++);

      } else if (currentThread->depth_first_number() < thisDfn) {

        // Thread already visited, and not on a (new) cycle

        break;

      } else if (currentThread == previousThread) {

        // Self-loop, ignore

        break;

      } else {

        // We have a (new) cycle

        num_deadlocks++;

        cycle->set_deadlock(true);

        // add this cycle to the deadlocks list

        if (deadlocks == NULL) {

          deadlocks = cycle;

        } else {

          last->set_next(cycle);

        }

        last = cycle;

        cycle = new DeadlockCycle();

        break;

      }

      previousThread = currentThread;

      waitingToLockMonitor = (ObjectMonitor*)currentThread->current_pending_monitor();

      if (concurrent_locks) {

        waitingToLockBlocker = currentThread->current_park_blocker();

      }

    }

  }

  delete cycle;

  return deadlocks;

}

ThreadDumpResult::ThreadDumpResult() : _num_threads(0), _num_snapshots(0), _snapshots(NULL), _last(NULL), _next(NULL), _setter() {

  // Create a new ThreadDumpResult object and append to the list.

  // If GC happens before this function returns, Method*

  // in the stack trace will be visited.

  ThreadService::add_thread_dump(this);

}

ThreadDumpResult::ThreadDumpResult(int num_threads) : _num_threads(num_threads), _num_snapshots(0), _snapshots(NULL), _last(NULL), _next(NULL), _setter() {

  // Create a new ThreadDumpResult object and append to the list.

  // If GC happens before this function returns, oops

  // will be visited.

  ThreadService::add_thread_dump(this);

}

ThreadDumpResult::~ThreadDumpResult() {

  ThreadService::remove_thread_dump(this);

  // free all the ThreadSnapshot objects created during

  // the VM_ThreadDump operation

  ThreadSnapshot* ts = _snapshots;

  while (ts != NULL) {

    ThreadSnapshot* p = ts;

    ts = ts->next();

    delete p;

  }

}

ThreadSnapshot* ThreadDumpResult::add_thread_snapshot() {

  ThreadSnapshot* ts = new ThreadSnapshot();

  link_thread_snapshot(ts);

  return ts;

}