/*
 * Copyright (c) 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.
 *
 */

#ifndef SHARE_RUNTIME_MUTEX_INLINE_HPP
#define SHARE_RUNTIME_MUTEX_INLINE_HPP

#include "runtime/mutex.hpp"
#include "runtime/os.inline.hpp"
#include "runtime/thread.hpp"

inline bool Mutex::try_lock(Thread* self) {
  // Some safepoint_check_always locks use try_lock, so cannot check
  // safepoint state, but can check blocking state.
  check_block_state(self);
  if (_lock.try_lock()) {
    assert_owner(NULL);
    set_owner(self);
    return true;
  }
  return false;
}

inline bool Mutex::try_lock() {
  return this->try_lock(Thread::current());
}

inline void Mutex::lock(Thread* self) {
  if (try_lock(self)) {
    return;
  }
  lock_slow(self);
}

inline void Mutex::lock() {
  this->lock(Thread::current());
}

// JavaThreads when it is known to be safe to not check for a safepoint when
// acquiring this lock. If the thread blocks acquiring the lock it is not
// safepoint-safe and so will prevent a safepoint from being reached. If used
// in the wrong way this can lead to a deadlock with the safepoint code.
inline void Mutex::lock_without_safepoint_check(Thread * self) {
  check_no_safepoint_state(self);
  assert(_owner != self, "invariant");
  _lock.lock();
  assert_owner(NULL);
  set_owner(self);
}

inline void Mutex::lock_without_safepoint_check() {
  lock_without_safepoint_check(Thread::current());
}

inline void Mutex::release_for_safepoint() {
  assert_owner(NULL);
  _lock.unlock();
}

inline void Mutex::unlock() {
  assert_owner(Thread::current());
  set_owner(NULL);
  _lock.unlock();
}

// Lock without safepoint check - a degenerate variant of lock() for use by

#endif // SHARE_RUNTIME_MUTEX_INLINE_HPP