use of com.ibm.j9ddr.vm29.pointer.generated.J9ThreadMonitorPointer in project openj9 by eclipse.
the class DeadlockUtils method readObjectMonitors.
/**
* Returns a hash map of Object Pointers to their respective mutex (Object Monitor or System Monitor)
* @param vm
* @return
* @throws CorruptDataException
*/
public static HashMap<J9ObjectPointer, Object> readObjectMonitors(J9JavaVMPointer vm) throws CorruptDataException {
HashMap<J9ObjectPointer, Object> objectMonitorsMap = new HashMap<J9ObjectPointer, Object>();
MonitorIterator iterator = new MonitorIterator(vm);
while (iterator.hasNext()) {
Object current = iterator.next();
if (current instanceof ObjectMonitor) {
ObjectMonitor mon = (ObjectMonitor) current;
J9ObjectPointer object = mon.getObject();
objectMonitorsMap.put(object, mon);
} else if (current instanceof J9ThreadMonitorPointer) {
// System Monitor
J9ThreadMonitorPointer mon = (J9ThreadMonitorPointer) current;
J9ThreadAbstractMonitorPointer lock = J9ThreadAbstractMonitorPointer.cast(mon);
if (false == lock.userData().eq(0)) {
// this is an object monitor in the system monitor table
J9ObjectPointer object = J9ObjectPointer.cast(lock.userData());
objectMonitorsMap.put(object, mon);
}
}
}
return objectMonitorsMap;
}
use of com.ibm.j9ddr.vm29.pointer.generated.J9ThreadMonitorPointer in project openj9 by eclipse.
the class DeadlockUtils method findThreadCycle.
/**
* @param vmThread
* @param map
* @throws CorruptDataException
*/
public static void findThreadCycle(J9ThreadPointer aThread, HashMap<Integer, NativeDeadlockGraphNode> deadlocks, HashMap<J9ObjectPointer, Object> objectMonitorsMap) throws CorruptDataException {
// Based on JavaCoreDumpWriter::findThreadCycle()
// Can't stack allocate or (safely) re-purpose an object in Java,
// so we create a new one on each iteration, this is slightly
// different from what is done in javadump.cpp
NativeDeadlockGraphNode node = null;
NativeDeadlockGraphNode prev = null;
do {
// Is there an associated J9VMThread?
J9VMThreadPointer vmThread = J9ThreadHelper.getVMThread(aThread);
boolean isJavaThread = (null != vmThread) && vmThread.notNull();
// Enter waiter (blocked) or notify waiter.
boolean isJavaWaiter = false;
if (isJavaThread) {
// There is, so grab all the J9VMThread related information.
JavaDeadlockGraphNode javaNode = new JavaDeadlockGraphNode();
javaNode.javaThread = vmThread;
J9VMThreadPointer owner = null;
J9ObjectPointer lockObject = null;
J9ThreadAbstractMonitorPointer lock = null;
// Functionally equivalent to getVMThreadStateHelper(...) in thrinfo.c
lockObject = vmThread.blockingEnterObject();
if ((null != lockObject) && lockObject.notNull()) {
// This condition hitting means we are in one of the desired states:
// J9VMTHREAD_STATE_BLOCKED
// J9VMTHREAD_STATE_WAITING, J9VMTHREAD_STATE_WAITING_TIMED
// J9VMTHREAD_STATE_PARKED, J9VMTHREAD_STATE_PARKED_TIMED
isJavaWaiter = true;
// The original native relies on getVMThreadStateHelper(...)
// from thrinfo.c to obtain this information, which is analogous
// to J9VMThreadPointerUtil.getJ9State(...), but we don't actually
// need all that information.
Object current = objectMonitorsMap.get(lockObject);
if (current instanceof ObjectMonitor) {
ObjectMonitor mon = (ObjectMonitor) current;
owner = mon.getOwner();
lock = mon.getInflatedMonitor();
} else if (current instanceof J9ThreadMonitorPointer) {
// System Monitor
J9ThreadMonitorPointer mon = (J9ThreadMonitorPointer) current;
J9ThreadPointer sysThread = mon.owner();
lock = J9ThreadAbstractMonitorPointer.cast(mon);
if (sysThread.notNull()) {
owner = J9ThreadHelper.getVMThread(sysThread);
}
}
if ((null == owner) || owner.isNull() || (owner.equals(vmThread))) {
// See JAZZ103 63676: There are cases where even if we know there is no
// Java deadlock, we should still check for a system deadlock.
// We simply deal with this node as a native one from this point on.
isJavaWaiter = false;
} else {
// N.B. In the native there are comparisons with J9VMTHREAD_STATE_*
// constants as returned by the helper, but here we don't actually need them.
javaNode.javaLock = lock;
javaNode.lockObject = lockObject;
javaNode.cycle = 0;
/* Record current thread and update last node */
javaNode.nativeThread = vmThread.osThread();
deadlocks.put(javaNode.hashCode(), javaNode);
if (null != prev) {
prev.next = javaNode;
}
/* Move around the graph */
prev = javaNode;
/* Peek ahead to see if we're in a possible cycle */
prev.next = deadlocks.get(owner.osThread().hashCode());
aThread = owner.osThread();
}
}
// Have to keep going for the case of Java thread blocking on system monitor.
// We have to write the J9Thread info as well.
node = javaNode;
}
if (false == isJavaThread) {
node = new NativeDeadlockGraphNode();
}
// Now get all of the J9Thread fields (even when we are working with a Java thread).
node.nativeThread = aThread;
J9ThreadMonitorPointer nativeLock = aThread.monitor();
J9ThreadPointer owner = null;
if ((null == nativeLock) || nativeLock.isNull()) {
if (false == isJavaThread) {
return;
}
} else {
node.nativeLock = nativeLock;
owner = nativeLock.owner();
}
// to change the pointers, otherwise we have to set them up.
if (false == isJavaWaiter) {
deadlocks.put(node.hashCode(), node);
if (null != prev) {
prev.next = node;
}
if ((null == owner) || owner.isNull() || (owner.equals(aThread))) {
return;
} else {
/* Move around the graph */
prev = node;
/* Peek ahead to see if we're in a possible cycle */
prev.next = deadlocks.get(owner.hashCode());
aThread = owner;
}
}
} while (// Quit as soon as possible (first node we've already visited).
null == prev.next);
// The rest of the cycles will be found by multiple calls to findThreadCycle(...)
}
Aggregations