27 import java.io.*;
28 import java.util.*;
29 import sun.jvm.hotspot.debugger.*;
30 import sun.jvm.hotspot.oops.*;
31 import sun.jvm.hotspot.types.*;
32 import sun.jvm.hotspot.utilities.*;
33 import sun.jvm.hotspot.utilities.Observable;
34 import sun.jvm.hotspot.utilities.Observer;
35
36 /** This is an abstract class because there are certain OS- and
37 CPU-specific operations (like the setting and getting of the last
38 Java frame pointer) which need to be factored out. These
39 operations are implemented by, for example,
40 SolarisSPARCJavaThread, and the concrete subclasses are
41 instantiated by the JavaThreadFactory in the Threads class. */
42
43 public class JavaThread extends Thread {
44 private static final boolean DEBUG = System.getProperty("sun.jvm.hotspot.runtime.JavaThread.DEBUG") != null;
45
46 private static long threadObjFieldOffset;
47 private static AddressField anchorField;
48 private static AddressField lastJavaSPField;
49 private static AddressField lastJavaPCField;
50 private static CIntegerField threadStateField;
51 private static AddressField osThreadField;
52 private static AddressField stackBaseField;
53 private static CIntegerField stackSizeField;
54 private static CIntegerField terminatedField;
55 private static AddressField activeHandlesField;
56
57 private static JavaThreadPDAccess access;
58
59 // JavaThreadStates read from underlying process
60 private static int UNINITIALIZED;
61 private static int NEW;
62 private static int NEW_TRANS;
63 private static int IN_NATIVE;
64 private static int IN_NATIVE_TRANS;
65 private static int IN_VM;
66 private static int IN_VM_TRANS;
67 private static int IN_JAVA;
68 private static int IN_JAVA_TRANS;
69 private static int BLOCKED;
70 private static int BLOCKED_TRANS;
71
72 private static int NOT_TERMINATED;
73 private static int EXITING;
74
75 private static final String ADDRESS_FORMAT = VM.getVM().isLP64() ? "0x%016x" : "0x%08x";
76
77 static {
78 VM.registerVMInitializedObserver(new Observer() {
79 public void update(Observable o, Object data) {
80 initialize(VM.getVM().getTypeDataBase());
81 }
82 });
83 }
84
85 private static synchronized void initialize(TypeDataBase db) {
86 Type type = db.lookupType("JavaThread");
87 Type anchorType = db.lookupType("JavaFrameAnchor");
88
89 threadObjFieldOffset = type.getField("_threadObj").getOffset();
90
91 anchorField = type.getAddressField("_anchor");
92 lastJavaSPField = anchorType.getAddressField("_last_Java_sp");
93 lastJavaPCField = anchorType.getAddressField("_last_Java_pc");
94 threadStateField = type.getCIntegerField("_thread_state");
95 osThreadField = type.getAddressField("_osthread");
96 stackBaseField = type.getAddressField("_stack_base");
97 stackSizeField = type.getCIntegerField("_stack_size");
98 terminatedField = type.getCIntegerField("_terminated");
99 activeHandlesField = type.getAddressField("_active_handles");
100
101 UNINITIALIZED = db.lookupIntConstant("_thread_uninitialized").intValue();
102 NEW = db.lookupIntConstant("_thread_new").intValue();
103 NEW_TRANS = db.lookupIntConstant("_thread_new_trans").intValue();
104 IN_NATIVE = db.lookupIntConstant("_thread_in_native").intValue();
105 IN_NATIVE_TRANS = db.lookupIntConstant("_thread_in_native_trans").intValue();
106 IN_VM = db.lookupIntConstant("_thread_in_vm").intValue();
107 IN_VM_TRANS = db.lookupIntConstant("_thread_in_vm_trans").intValue();
108 IN_JAVA = db.lookupIntConstant("_thread_in_Java").intValue();
109 IN_JAVA_TRANS = db.lookupIntConstant("_thread_in_Java_trans").intValue();
110 BLOCKED = db.lookupIntConstant("_thread_blocked").intValue();
111 BLOCKED_TRANS = db.lookupIntConstant("_thread_blocked_trans").intValue();
112
113 NOT_TERMINATED = db.lookupIntConstant("JavaThread::_not_terminated").intValue();
114 EXITING = db.lookupIntConstant("JavaThread::_thread_exiting").intValue();
115
116 }
117
118 public JavaThread(Address addr) {
119 super(addr);
120 }
377
378 // FIXME: add in the rest of the routine from the VM
379
380 // Traverse the execution stack
381 for(StackFrameStream fst = new StackFrameStream(this); !fst.isDone(); fst.next()) {
382 fst.getCurrent().oopsDo(oopVisitor, fst.getRegisterMap());
383 }
384 }
385
386 public boolean isInStack(Address a) {
387 if (Assert.ASSERTS_ENABLED) {
388 Assert.that(VM.getVM().isDebugging(), "Not yet implemented for non-debugging system");
389 }
390 Address sp = lastSPDbg();
391 Address stackBase = getStackBase();
392 // Be robust
393 if (sp == null) return false;
394 return stackBase.greaterThan(a) && sp.lessThanOrEqual(a);
395 }
396
397 public boolean isLockOwned(Address a) {
398 Address stackBase = getStackBase();
399 Address stackLimit = stackBase.addOffsetTo(-getStackSize());
400
401 return stackBase.greaterThan(a) && stackLimit.lessThanOrEqual(a);
402
403 // FIXME: should traverse MonitorArray/MonitorChunks as in VM
404 }
405
406 public Oop getCurrentParkBlocker() {
407 Oop threadObj = getThreadObj();
408 if (threadObj != null) {
409 try {
410 return OopUtilities.threadOopGetParkBlocker(threadObj);
411 } catch (Exception e) {
412 System.out.println("Could not get current park blocker: " + e);
413 }
414 }
415 return null;
416 }
|
27 import java.io.*;
28 import java.util.*;
29 import sun.jvm.hotspot.debugger.*;
30 import sun.jvm.hotspot.oops.*;
31 import sun.jvm.hotspot.types.*;
32 import sun.jvm.hotspot.utilities.*;
33 import sun.jvm.hotspot.utilities.Observable;
34 import sun.jvm.hotspot.utilities.Observer;
35
36 /** This is an abstract class because there are certain OS- and
37 CPU-specific operations (like the setting and getting of the last
38 Java frame pointer) which need to be factored out. These
39 operations are implemented by, for example,
40 SolarisSPARCJavaThread, and the concrete subclasses are
41 instantiated by the JavaThreadFactory in the Threads class. */
42
43 public class JavaThread extends Thread {
44 private static final boolean DEBUG = System.getProperty("sun.jvm.hotspot.runtime.JavaThread.DEBUG") != null;
45
46 private static long threadObjFieldOffset;
47 private static long lockStackCurrentOffset;
48 private static long lockStackBaseOffset;
49 private static AddressField anchorField;
50 private static AddressField lastJavaSPField;
51 private static AddressField lastJavaPCField;
52 private static CIntegerField threadStateField;
53 private static AddressField osThreadField;
54 private static AddressField stackBaseField;
55 private static CIntegerField stackSizeField;
56 private static CIntegerField terminatedField;
57 private static AddressField activeHandlesField;
58 private static long oopPtrSize;
59
60 private static JavaThreadPDAccess access;
61
62 // JavaThreadStates read from underlying process
63 private static int UNINITIALIZED;
64 private static int NEW;
65 private static int NEW_TRANS;
66 private static int IN_NATIVE;
67 private static int IN_NATIVE_TRANS;
68 private static int IN_VM;
69 private static int IN_VM_TRANS;
70 private static int IN_JAVA;
71 private static int IN_JAVA_TRANS;
72 private static int BLOCKED;
73 private static int BLOCKED_TRANS;
74
75 private static int NOT_TERMINATED;
76 private static int EXITING;
77
78 private static final String ADDRESS_FORMAT = VM.getVM().isLP64() ? "0x%016x" : "0x%08x";
79
80 static {
81 VM.registerVMInitializedObserver(new Observer() {
82 public void update(Observable o, Object data) {
83 initialize(VM.getVM().getTypeDataBase());
84 }
85 });
86 }
87
88 private static synchronized void initialize(TypeDataBase db) {
89 Type type = db.lookupType("JavaThread");
90 Type anchorType = db.lookupType("JavaFrameAnchor");
91 Type typeLockStack = db.lookupType("LockStack");
92
93 threadObjFieldOffset = type.getField("_threadObj").getOffset();
94
95 anchorField = type.getAddressField("_anchor");
96 lastJavaSPField = anchorType.getAddressField("_last_Java_sp");
97 lastJavaPCField = anchorType.getAddressField("_last_Java_pc");
98 threadStateField = type.getCIntegerField("_thread_state");
99 osThreadField = type.getAddressField("_osthread");
100 stackBaseField = type.getAddressField("_stack_base");
101 stackSizeField = type.getCIntegerField("_stack_size");
102 terminatedField = type.getCIntegerField("_terminated");
103 activeHandlesField = type.getAddressField("_active_handles");
104
105 lockStackCurrentOffset = type.getField("_lock_stack").getOffset() + typeLockStack.getField("_current").getOffset();
106 lockStackBaseOffset = type.getField("_lock_stack").getOffset() + typeLockStack.getField("_base").getOffset();
107 oopPtrSize = VM.getVM().getAddressSize();
108
109 UNINITIALIZED = db.lookupIntConstant("_thread_uninitialized").intValue();
110 NEW = db.lookupIntConstant("_thread_new").intValue();
111 NEW_TRANS = db.lookupIntConstant("_thread_new_trans").intValue();
112 IN_NATIVE = db.lookupIntConstant("_thread_in_native").intValue();
113 IN_NATIVE_TRANS = db.lookupIntConstant("_thread_in_native_trans").intValue();
114 IN_VM = db.lookupIntConstant("_thread_in_vm").intValue();
115 IN_VM_TRANS = db.lookupIntConstant("_thread_in_vm_trans").intValue();
116 IN_JAVA = db.lookupIntConstant("_thread_in_Java").intValue();
117 IN_JAVA_TRANS = db.lookupIntConstant("_thread_in_Java_trans").intValue();
118 BLOCKED = db.lookupIntConstant("_thread_blocked").intValue();
119 BLOCKED_TRANS = db.lookupIntConstant("_thread_blocked_trans").intValue();
120
121 NOT_TERMINATED = db.lookupIntConstant("JavaThread::_not_terminated").intValue();
122 EXITING = db.lookupIntConstant("JavaThread::_thread_exiting").intValue();
123
124 }
125
126 public JavaThread(Address addr) {
127 super(addr);
128 }
385
386 // FIXME: add in the rest of the routine from the VM
387
388 // Traverse the execution stack
389 for(StackFrameStream fst = new StackFrameStream(this); !fst.isDone(); fst.next()) {
390 fst.getCurrent().oopsDo(oopVisitor, fst.getRegisterMap());
391 }
392 }
393
394 public boolean isInStack(Address a) {
395 if (Assert.ASSERTS_ENABLED) {
396 Assert.that(VM.getVM().isDebugging(), "Not yet implemented for non-debugging system");
397 }
398 Address sp = lastSPDbg();
399 Address stackBase = getStackBase();
400 // Be robust
401 if (sp == null) return false;
402 return stackBase.greaterThan(a) && sp.lessThanOrEqual(a);
403 }
404
405 public boolean isLockOwned(OopHandle obj) {
406 Address current = addr.getAddressAt(lockStackCurrentOffset);
407 Address base = addr.getAddressAt(lockStackBaseOffset);
408 while (base.lessThan(current)) {
409 Address oop = base.getAddressAt(0);
410 if (oop.equals(obj)) {
411 return true;
412 }
413 base = base.addOffsetTo(oopPtrSize);
414 }
415 return false;
416 }
417
418 public boolean isLockOwned(Address a) {
419 Address stackBase = getStackBase();
420 Address stackLimit = stackBase.addOffsetTo(-getStackSize());
421
422 return stackBase.greaterThan(a) && stackLimit.lessThanOrEqual(a);
423
424 // FIXME: should traverse MonitorArray/MonitorChunks as in VM
425 }
426
427 public Oop getCurrentParkBlocker() {
428 Oop threadObj = getThreadObj();
429 if (threadObj != null) {
430 try {
431 return OopUtilities.threadOopGetParkBlocker(threadObj);
432 } catch (Exception e) {
433 System.out.println("Could not get current park blocker: " + e);
434 }
435 }
436 return null;
437 }
|