/*

 * 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 "memory/allocation.inline.hpp"

#include "prims/jvmtiRawMonitor.hpp"

#include "runtime/atomic.hpp"

#include "runtime/interfaceSupport.inline.hpp"

#include "runtime/orderAccess.hpp"

#include "runtime/thread.inline.hpp"

void JvmtiPendingMonitors::transition_raw_monitors() {

  assert((Threads::number_of_threads()==1),

is running. Raw monitor transition will not work");

  JavaThread *current_java_thread = JavaThread::current();

  assert(current_java_thread->thread_state() == _thread_in_vm, "Must be in vm");

  }

  // pending monitors are converted to real monitor so delete them all.

  dispose();

}

//

// class JvmtiRawMonitor

//

#ifdef ASSERT

  _name = strcpy(NEW_C_HEAP_ARRAY(char, strlen(name) + 1, mtInternal), name);

#endif

}

JvmtiRawMonitor::~JvmtiRawMonitor() {

#ifdef ASSERT

  FreeHeap(_name);

#endif

  _magic = 0;

}

bool

JvmtiRawMonitor::is_valid() {

  int value = 0;

  // This object might not be a JvmtiRawMonitor so we can't assume

  // the _magic field is properly aligned. Get the value in a safe

  // way and then check against JVMTI_RM_MAGIC.

  switch (sizeof(_magic)) {

  case 2:

    value = Bytes::get_native_u2((address)&_magic);

    break;

  case 4:

    value = Bytes::get_native_u4((address)&_magic);

    break;

  case 8:

    value = Bytes::get_native_u8((address)&_magic);

    break;

  default:

    guarantee(false, "_magic field is an unexpected size");

  }

  return value == JVMTI_RM_MAGIC;

}

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

// associated with objects.  They can be implemented in any manner

// that makes sense.  The original implementors decided to piggy-back

//

// Note that we use the single RawMonitor_lock to protect queue operations for

// _all_ raw monitors.  This is a scalability impediment, but since raw monitor usage

// be held indefinitely.  The critical sections must be short and bounded.

//

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

  for (;;) {

    if (Atomic::replace_if_null(Self, &_owner)) {

    }

    Self->_ParkEvent->reset() ;     // strictly optional

    RawMonitor_lock->lock_without_safepoint_check() ;

    Node._next  = _EntryList ;

    _EntryList  = &Node ;

    OrderAccess::fence() ;

    if (_owner == NULL && Atomic::replace_if_null(Self, &_owner)) {

        _EntryList = Node._next ;

        RawMonitor_lock->unlock() ;

    }

    RawMonitor_lock->unlock() ;

       Self->_ParkEvent->park() ;

    }

  }

}

  guarantee (_owner == Self, "invariant") ;

  OrderAccess::fence() ;

  RawMonitor_lock->lock_without_safepoint_check() ;

  w = _EntryList ;

  if (w != NULL) {

      _EntryList = w->_next ;

  }

  RawMonitor_lock->unlock() ;

  if (w != NULL) {

      // Once we set TState to TS_RUN the waiting thread can complete

      // SimpleEnter and 'w' is pointing into random stack space. So we have

      // to ensure we extract the ParkEvent (which is in type-stable memory)

      // before we set the state, and then don't access 'w'.

      ParkEvent * ev = w->_event ;

      OrderAccess::loadstore();

      OrderAccess::fence() ;

      ev->unpark() ;

  }

}

int JvmtiRawMonitor::SimpleWait (Thread * Self, jlong millis) {

  guarantee (_owner == Self  , "invariant") ;

  guarantee (_recursions == 0, "invariant") ;

  Node._notified = 0 ;

  RawMonitor_lock->lock_without_safepoint_check() ;

  Node._next     = _WaitSet ;

  _WaitSet       = &Node ;

  RawMonitor_lock->unlock() ;

  SimpleExit (Self) ;

  guarantee (_owner != Self, "invariant") ;

  int ret = OS_OK ;

  if (millis <= 0) {

    Self->_ParkEvent->park();

  } else {

    ret = Self->_ParkEvent->park(millis);

  }

  // If thread still resides on the waitset then unlink it.

  // Double-checked locking -- the usage is safe in this context

  // as TState is volatile and the lock-unlock operators are

  // serializing (barrier-equivalent).

    RawMonitor_lock->lock_without_safepoint_check() ;

      // Simple O(n) unlink, but performance isn't critical here.

      for (p = _WaitSet ; p != &Node; p = p->_next) {

         q = p ;

      }

      guarantee (p == &Node, "invariant") ;

      if (q == NULL) {

        guarantee (p == _WaitSet, "invariant") ;

        _WaitSet = p->_next ;

      } else {

        guarantee (p == q->_next, "invariant") ;

        q->_next = p->_next ;

      }

    }

    RawMonitor_lock->unlock() ;

  }

  SimpleEnter (Self) ;

  guarantee (_owner == Self, "invariant") ;

  guarantee (_recursions == 0, "invariant") ;

  return ret ;

}

  guarantee (_owner == Self, "invariant") ;

  // We have two options:

  // A. Transfer the threads from the WaitSet to the EntryList

  // B. Remove the thread from the WaitSet and unpark() it.

  //

  // We use (B), which is crude and results in lots of futile

  // context switching.  In particular (B) induces lots of contention.

  ParkEvent * ev = NULL ;       // consider using a small auto array ...

  RawMonitor_lock->lock_without_safepoint_check() ;

  for (;;) {

      if (w == NULL) break ;

      _WaitSet = w->_next ;

      if (ev != NULL) { ev->unpark(); ev = NULL; }

      ev = w->_event ;

      OrderAccess::loadstore() ;

      OrderAccess::storeload();

      if (!All) break ;

  }

  RawMonitor_lock->unlock() ;

  if (ev != NULL) ev->unpark();

}

// Any JavaThread will enter here with state _thread_blocked

  void * Contended ;

  // don't enter raw monitor if thread is being externally suspended, it will

  // surprise the suspender if a "suspended" thread can still enter monitor

    jt->SR_lock()->lock_without_safepoint_check();

    while (jt->is_external_suspend()) {

      jt->SR_lock()->unlock();

      jt->java_suspend_self();

      jt->SR_lock()->lock_without_safepoint_check();

    }

    // guarded by SR_lock to avoid racing with new external suspend requests.

    jt->SR_lock()->unlock();

  } else {

  }

     _recursions ++ ;

  }

  if (Contended == NULL) {

     guarantee (_recursions == 0, "invariant") ;

  }

  }

  guarantee (_recursions == 0, "invariant") ;

}

  }

  if (_recursions > 0) {

    --_recursions ;

  }

}

// All JavaThreads will enter here with state _thread_blocked

  }

  // To avoid spurious wakeups we reset the parkevent -- This is strictly optional.

  // The caller must be able to tolerate spurious returns from raw_wait().

  OrderAccess::fence() ;

  // check interrupt event

  if (interruptible) {

    if (jt->is_interrupted(true)) {

    }

  }

  intptr_t save = _recursions ;

  _recursions = 0 ;

  _waiters ++ ;

  }

  _recursions = save ;

  _waiters -- ;

     for (;;) {

     }

  }

  }

}

  }

}

  }

}