/*

 * Copyright (c) 1998, 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/vmSymbols.hpp"

#include "logging/log.hpp"

#include "logging/logStream.hpp"

#include "jfr/jfrEvents.hpp"

#include "memory/allocation.inline.hpp"

#include "memory/metaspaceShared.hpp"

#include "memory/padded.hpp"

#include "memory/resourceArea.hpp"

#include "memory/universe.hpp"

#include "oops/markWord.hpp"

#include "oops/oop.inline.hpp"

#include "runtime/atomic.hpp"

#include "runtime/biasedLocking.hpp"

#include "runtime/handles.inline.hpp"

#include "runtime/interfaceSupport.inline.hpp"

#include "runtime/mutexLocker.hpp"

#include "runtime/objectMonitor.hpp"

#include "runtime/objectMonitor.inline.hpp"

#include "runtime/osThread.hpp"

#include "runtime/safepointVerifiers.hpp"

#include "runtime/sharedRuntime.hpp"

#include "runtime/stubRoutines.hpp"

#include "runtime/synchronizer.hpp"

#include "runtime/thread.inline.hpp"

#include "runtime/timer.hpp"

#include "runtime/vframe.hpp"

#include "runtime/vmThread.hpp"

#include "utilities/align.hpp"

#include "utilities/dtrace.hpp"

#include "utilities/events.hpp"

#include "utilities/preserveException.hpp"

// The "core" versions of monitor enter and exit reside in this file.

// The interpreter and compilers contain specialized transliterated

// variants of the enter-exit fast-path operations.  See i486.ad fast_lock(),

// for instance.  If you make changes here, make sure to modify the

// interpreter, and both C1 and C2 fast-path inline locking code emission.

//

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

#ifdef DTRACE_ENABLED

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

// TODO-FIXME: probes should not fire when caller is _blocked.  assert() accordingly.

#define DTRACE_MONITOR_PROBE_COMMON(obj, thread)                           \

  char* bytes = NULL;                                                      \

  int len = 0;                                                             \

  jlong jtid = SharedRuntime::get_java_tid(thread);                        \

  Symbol* klassname = ((oop)(obj))->klass()->name();                       \

  if (klassname != NULL) {                                                 \

    bytes = (char*)klassname->bytes();                                     \

    len = klassname->utf8_length();                                        \

  }

#define DTRACE_MONITOR_WAIT_PROBE(monitor, obj, thread, millis)            \

  {                                                                        \

    if (DTraceMonitorProbes) {                                             \

      DTRACE_MONITOR_PROBE_COMMON(obj, thread);                            \

      HOTSPOT_MONITOR_WAIT(jtid,                                           \

                           (uintptr_t)(monitor), bytes, len, (millis));    \

    }                                                                      \

  }

#define HOTSPOT_MONITOR_PROBE_notify HOTSPOT_MONITOR_NOTIFY

#define HOTSPOT_MONITOR_PROBE_notifyAll HOTSPOT_MONITOR_NOTIFYALL

#define HOTSPOT_MONITOR_PROBE_waited HOTSPOT_MONITOR_WAITED

#define DTRACE_MONITOR_PROBE(probe, monitor, obj, thread)                  \

  {                                                                        \

    if (DTraceMonitorProbes) {                                             \

      DTRACE_MONITOR_PROBE_COMMON(obj, thread);                            \

      HOTSPOT_MONITOR_PROBE_##probe(jtid, /* probe = waited */             \

                                    (uintptr_t)(monitor), bytes, len);     \

    }                                                                      \

  }

#else //  ndef DTRACE_ENABLED

#define DTRACE_MONITOR_WAIT_PROBE(obj, thread, millis, mon)    {;}

#define DTRACE_MONITOR_PROBE(probe, obj, thread, mon)          {;}

#endif // ndef DTRACE_ENABLED

// This exists only as a workaround of dtrace bug 6254741

int dtrace_waited_probe(ObjectMonitor* monitor, Handle obj, Thread* thr) {

  DTRACE_MONITOR_PROBE(waited, monitor, obj(), thr);

  return 0;

}

#define NINFLATIONLOCKS 256

static volatile intptr_t gInflationLocks[NINFLATIONLOCKS];

// global list of blocks of monitors

PaddedObjectMonitor* volatile ObjectSynchronizer::g_block_list = NULL;

// Global ObjectMonitor free list. Newly allocated and deflated

// ObjectMonitors are prepended here.

ObjectMonitor* volatile ObjectSynchronizer::g_free_list = NULL;

// Global ObjectMonitor in-use list. When a JavaThread is exiting,

// ObjectMonitors on its per-thread in-use list are prepended here.

ObjectMonitor* volatile ObjectSynchronizer::g_om_in_use_list = NULL;

int ObjectSynchronizer::g_om_in_use_count = 0;  // # on g_om_in_use_list

static volatile intptr_t gListLock = 0;   // protects global monitor lists

static volatile int g_om_free_count = 0;  // # on g_free_list

static volatile int g_om_population = 0;  // # Extant -- in circulation

#define CHAINMARKER (cast_to_oop<intptr_t>(-1))

// =====================> Quick functions

// The quick_* forms are special fast-path variants used to improve

// performance.  In the simplest case, a "quick_*" implementation could

// simply return false, in which case the caller will perform the necessary

// state transitions and call the slow-path form.

// The fast-path is designed to handle frequently arising cases in an efficient

// manner and is just a degenerate "optimistic" variant of the slow-path.

// returns true  -- to indicate the call was satisfied.

// returns false -- to indicate the call needs the services of the slow-path.

// A no-loitering ordinance is in effect for code in the quick_* family

// operators: safepoints or indefinite blocking (blocking that might span a

// safepoint) are forbidden. Generally the thread_state() is _in_Java upon

// entry.

//

// Consider: An interesting optimization is to have the JIT recognize the

// following common idiom:

//   synchronized (someobj) { .... ; notify(); }

// That is, we find a notify() or notifyAll() call that immediately precedes

// the monitorexit operation.  In that case the JIT could fuse the operations

// into a single notifyAndExit() runtime primitive.

bool ObjectSynchronizer::quick_notify(oopDesc* obj, Thread* self, bool all) {

  assert(!SafepointSynchronize::is_at_safepoint(), "invariant");

  assert(self->is_Java_thread(), "invariant");

  assert(((JavaThread *) self)->thread_state() == _thread_in_Java, "invariant");

  NoSafepointVerifier nsv;

  if (obj == NULL) return false;  // slow-path for invalid obj

  const markWord mark = obj->mark();

  if (mark.has_locker() && self->is_lock_owned((address)mark.locker())) {

    // Degenerate notify

    // stack-locked by caller so by definition the implied waitset is empty.

    return true;

  }

  if (mark.has_monitor()) {

    ObjectMonitor* const mon = mark.monitor();

    assert(mon->object() == obj, "invariant");

    if (mon->owner() != self) return false;  // slow-path for IMS exception

    if (mon->first_waiter() != NULL) {

      // We have one or more waiters. Since this is an inflated monitor

      // that we own, we can transfer one or more threads from the waitset

      // to the entrylist here and now, avoiding the slow-path.

      if (all) {

        DTRACE_MONITOR_PROBE(notifyAll, mon, obj, self);

      } else {

        DTRACE_MONITOR_PROBE(notify, mon, obj, self);

      }

      int free_count = 0;

      do {

        mon->INotify(self);

        ++free_count;

      } while (mon->first_waiter() != NULL && all);

      OM_PERFDATA_OP(Notifications, inc(free_count));

    }

    return true;

  }

  // biased locking and any other IMS exception states take the slow-path

  return false;

}

// The LockNode emitted directly at the synchronization site would have

// been too big if it were to have included support for the cases of inflated

// recursive enter and exit, so they go here instead.

// Note that we can't safely call AsyncPrintJavaStack() from within

// quick_enter() as our thread state remains _in_Java.

bool ObjectSynchronizer::quick_enter(oop obj, Thread* self,

                                     BasicLock * lock) {

  assert(!SafepointSynchronize::is_at_safepoint(), "invariant");

  assert(self->is_Java_thread(), "invariant");

  assert(((JavaThread *) self)->thread_state() == _thread_in_Java, "invariant");

  NoSafepointVerifier nsv;

  if (obj == NULL) return false;       // Need to throw NPE

  const markWord mark = obj->mark();

  if (mark.has_monitor()) {

    ObjectMonitor* const m = mark.monitor();

    assert(m->object() == obj, "invariant");

    Thread* const owner = (Thread *) m->_owner;

    // Lock contention and Transactional Lock Elision (TLE) diagnostics

    // and observability

    // Case: light contention possibly amenable to TLE

    // Case: TLE inimical operations such as nested/recursive synchronization

    if (owner == self) {

      m->_recursions++;

      return true;

    }

    // This Java Monitor is inflated so obj's header will never be

    // displaced to this thread's BasicLock. Make the displaced header

    // non-NULL so this BasicLock is not seen as recursive nor as

    // being locked. We do this unconditionally so that this thread's

    // BasicLock cannot be mis-interpreted by any stack walkers. For

    // performance reasons, stack walkers generally first check for

    // Biased Locking in the object's header, the second check is for

    // stack-locking in the object's header, the third check is for

    // recursive stack-locking in the displaced header in the BasicLock,

    // and last are the inflated Java Monitor (ObjectMonitor) checks.

    lock->set_displaced_header(markWord::unused_mark());

    if (owner == NULL && Atomic::replace_if_null(&(m->_owner), self)) {

      assert(m->_recursions == 0, "invariant");

      return true;

    }

  }

  // Note that we could inflate in quick_enter.

  // This is likely a useful optimization

  // Critically, in quick_enter() we must not:

  // -- perform bias revocation, or

  // -- block indefinitely, or

  // -- reach a safepoint

  return false;        // revert to slow-path

}

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

// Monitor Enter/Exit

// The interpreter and compiler assembly code tries to lock using the fast path

// of this algorithm. Make sure to update that code if the following function is

// changed. The implementation is extremely sensitive to race condition. Be careful.

void ObjectSynchronizer::enter(Handle obj, BasicLock* lock, TRAPS) {

  if (UseBiasedLocking) {

    if (!SafepointSynchronize::is_at_safepoint()) {

      BiasedLocking::revoke(obj, THREAD);

    } else {

      BiasedLocking::revoke_at_safepoint(obj);

    }

  }

  markWord mark = obj->mark();

  assert(!mark.has_bias_pattern(), "should not see bias pattern here");

  if (mark.is_neutral()) {

    // Anticipate successful CAS -- the ST of the displaced mark must

    // be visible <= the ST performed by the CAS.

    lock->set_displaced_header(mark);

    if (mark == obj()->cas_set_mark(markWord::from_pointer(lock), mark)) {

      return;

    }

    // Fall through to inflate() ...

  } else if (mark.has_locker() &&

             THREAD->is_lock_owned((address)mark.locker())) {

    assert(lock != mark.locker(), "must not re-lock the same lock");

    assert(lock != (BasicLock*)obj->mark().value(), "don't relock with same BasicLock");

    lock->set_displaced_header(markWord::from_pointer(NULL));

    return;

  }

  // The object header will never be displaced to this lock,

  // so it does not matter what the value is, except that it

  // must be non-zero to avoid looking like a re-entrant lock,

  // and must not look locked either.

  lock->set_displaced_header(markWord::unused_mark());

  inflate(THREAD, obj(), inflate_cause_monitor_enter)->enter(THREAD);

}

void ObjectSynchronizer::exit(oop object, BasicLock* lock, TRAPS) {

  markWord mark = object->mark();

  // We cannot check for Biased Locking if we are racing an inflation.

  assert(mark == markWord::INFLATING() ||

         !mark.has_bias_pattern(), "should not see bias pattern here");

  markWord dhw = lock->displaced_header();

  if (dhw.value() == 0) {

    // If the displaced header is NULL, then this exit matches up with

    // a recursive enter. No real work to do here except for diagnostics.

#ifndef PRODUCT

    if (mark != markWord::INFLATING()) {

      // Only do diagnostics if we are not racing an inflation. Simply

      // exiting a recursive enter of a Java Monitor that is being

      // inflated is safe; see the has_monitor() comment below.

      assert(!mark.is_neutral(), "invariant");

      assert(!mark.has_locker() ||

             THREAD->is_lock_owned((address)mark.locker()), "invariant");

      if (mark.has_monitor()) {

        // The BasicLock's displaced_header is marked as a recursive

        // enter and we have an inflated Java Monitor (ObjectMonitor).

        // This is a special case where the Java Monitor was inflated

        // after this thread entered the stack-lock recursively. When a

        // Java Monitor is inflated, we cannot safely walk the Java

        // Monitor owner's stack and update the BasicLocks because a

        // Java Monitor can be asynchronously inflated by a thread that

        // does not own the Java Monitor.

        ObjectMonitor* m = mark.monitor();

        assert(((oop)(m->object()))->mark() == mark, "invariant");

        assert(m->is_entered(THREAD), "invariant");

      }

    }

#endif

    return;

  }

  if (mark == markWord::from_pointer(lock)) {

    // If the object is stack-locked by the current thread, try to

    // swing the displaced header from the BasicLock back to the mark.

    assert(dhw.is_neutral(), "invariant");

    if (object->cas_set_mark(dhw, mark) == mark) {

      return;

    }

  }

  // We have to take the slow-path of possible inflation and then exit.

  inflate(THREAD, object, inflate_cause_vm_internal)->exit(true, THREAD);

}

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

// Class Loader  support to workaround deadlocks on the class loader lock objects

// Also used by GC

// complete_exit()/reenter() are used to wait on a nested lock

// i.e. to give up an outer lock completely and then re-enter

// Used when holding nested locks - lock acquisition order: lock1 then lock2

//  1) complete_exit lock1 - saving recursion count

//  2) wait on lock2

//  3) when notified on lock2, unlock lock2

//  4) reenter lock1 with original recursion count

//  5) lock lock2

// NOTE: must use heavy weight monitor to handle complete_exit/reenter()

intx ObjectSynchronizer::complete_exit(Handle obj, TRAPS) {

  if (UseBiasedLocking) {

    BiasedLocking::revoke(obj, THREAD);

    assert(!obj->mark().has_bias_pattern(), "biases should be revoked by now");

  }

  ObjectMonitor* monitor = inflate(THREAD, obj(), inflate_cause_vm_internal);

  return monitor->complete_exit(THREAD);

}

// NOTE: must use heavy weight monitor to handle complete_exit/reenter()

void ObjectSynchronizer::reenter(Handle obj, intx recursions, TRAPS) {

  if (UseBiasedLocking) {

    BiasedLocking::revoke(obj, THREAD);

    assert(!obj->mark().has_bias_pattern(), "biases should be revoked by now");

  }

  ObjectMonitor* monitor = inflate(THREAD, obj(), inflate_cause_vm_internal);

  monitor->reenter(recursions, THREAD);

}

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

// JNI locks on java objects

// NOTE: must use heavy weight monitor to handle jni monitor enter

void ObjectSynchronizer::jni_enter(Handle obj, TRAPS) {

  // the current locking is from JNI instead of Java code

  if (UseBiasedLocking) {

    BiasedLocking::revoke(obj, THREAD);

    assert(!obj->mark().has_bias_pattern(), "biases should be revoked by now");

  }

  THREAD->set_current_pending_monitor_is_from_java(false);

  inflate(THREAD, obj(), inflate_cause_jni_enter)->enter(THREAD);

  THREAD->set_current_pending_monitor_is_from_java(true);

}

// NOTE: must use heavy weight monitor to handle jni monitor exit

void ObjectSynchronizer::jni_exit(oop obj, Thread* THREAD) {

  if (UseBiasedLocking) {

    Handle h_obj(THREAD, obj);

    BiasedLocking::revoke(h_obj, THREAD);

    obj = h_obj();

  }

  assert(!obj->mark().has_bias_pattern(), "biases should be revoked by now");

  ObjectMonitor* monitor = inflate(THREAD, obj, inflate_cause_jni_exit);

  // If this thread has locked the object, exit the monitor. We

  // intentionally do not use CHECK here because we must exit the

  // monitor even if an exception is pending.

  if (monitor->check_owner(THREAD)) {

    monitor->exit(true, THREAD);

  }

}

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

// Internal VM locks on java objects

// standard constructor, allows locking failures

ObjectLocker::ObjectLocker(Handle obj, Thread* thread, bool do_lock) {

  _dolock = do_lock;

  _thread = thread;

  _thread->check_for_valid_safepoint_state();

  _obj = obj;

  if (_dolock) {

    ObjectSynchronizer::enter(_obj, &_lock, _thread);

  }

}

ObjectLocker::~ObjectLocker() {

  if (_dolock) {

    ObjectSynchronizer::exit(_obj(), &_lock, _thread);

  }

}

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

//  Wait/Notify/NotifyAll

// NOTE: must use heavy weight monitor to handle wait()

int ObjectSynchronizer::wait(Handle obj, jlong millis, TRAPS) {

  if (UseBiasedLocking) {

    BiasedLocking::revoke(obj, THREAD);

    assert(!obj->mark().has_bias_pattern(), "biases should be revoked by now");

  }

  if (millis < 0) {

    THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(), "timeout value is negative");

  }

  ObjectMonitor* monitor = inflate(THREAD, obj(), inflate_cause_wait);

  DTRACE_MONITOR_WAIT_PROBE(monitor, obj(), THREAD, millis);

  monitor->wait(millis, true, THREAD);

  // This dummy call is in place to get around dtrace bug 6254741.  Once

  // that's fixed we can uncomment the following line, remove the call

  // and change this function back into a "void" func.

  // DTRACE_MONITOR_PROBE(waited, monitor, obj(), THREAD);

  return dtrace_waited_probe(monitor, obj, THREAD);

}

void ObjectSynchronizer::wait_uninterruptibly(Handle obj, jlong millis, TRAPS) {

  if (UseBiasedLocking) {

    BiasedLocking::revoke(obj, THREAD);

    assert(!obj->mark().has_bias_pattern(), "biases should be revoked by now");

  }

  if (millis < 0) {

    THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(), "timeout value is negative");

  }

  inflate(THREAD, obj(), inflate_cause_wait)->wait(millis, false, THREAD);

}

void ObjectSynchronizer::notify(Handle obj, TRAPS) {

  if (UseBiasedLocking) {

    BiasedLocking::revoke(obj, THREAD);

    assert(!obj->mark().has_bias_pattern(), "biases should be revoked by now");

  }

  markWord mark = obj->mark();

  if (mark.has_locker() && THREAD->is_lock_owned((address)mark.locker())) {

    return;

  }

  inflate(THREAD, obj(), inflate_cause_notify)->notify(THREAD);

}

// NOTE: see comment of notify()

void ObjectSynchronizer::notifyall(Handle obj, TRAPS) {