src/hotspot/share/services/threadService.cpp

@@ -42,11 +42,10 @@
  #include "prims/jvmtiRawMonitor.hpp"
  #include "prims/jvmtiThreadState.hpp"
  #include "runtime/atomicAccess.hpp"
  #include "runtime/handles.inline.hpp"
  #include "runtime/init.hpp"
- #include "runtime/javaCalls.hpp"
  #include "runtime/javaThread.inline.hpp"
  #include "runtime/jniHandles.inline.hpp"
  #include "runtime/objectMonitor.inline.hpp"
  #include "runtime/synchronizer.hpp"
  #include "runtime/thread.inline.hpp"

@@ -1120,11 +1119,10 @@
    }
  }
  
  
  // jdk.internal.vm.ThreadSnapshot support
- #if INCLUDE_JVMTI
  
  class GetThreadSnapshotHandshakeClosure: public HandshakeClosure {
  private:
    static OopStorage* oop_storage() {
      assert(_thread_service_storage != nullptr, "sanity");

@@ -1171,23 +1169,24 @@
        return _type == NOTHING;
      }
    };
  
    Handle _thread_h;
+   jboolean _include_monitors;
    JavaThread* _java_thread;
    int _frame_count; // length of _methods and _bcis arrays
    GrowableArray<Method*>* _methods;
    GrowableArray<int>* _bcis;
    JavaThreadStatus _thread_status;
    OopHandle _thread_name;
    OopHandle _carrier_thread;
    GrowableArray<OwnedLock>* _locks;
    Blocker _blocker;
  
-   GetThreadSnapshotHandshakeClosure(Handle thread_h):
+   GetThreadSnapshotHandshakeClosure(Handle thread_h, jboolean include_monitors):
      HandshakeClosure("GetThreadSnapshotHandshakeClosure"),
-     _thread_h(thread_h), _java_thread(nullptr),
+     _thread_h(thread_h), _include_monitors(include_monitors), _java_thread(nullptr),
      _frame_count(0), _methods(nullptr), _bcis(nullptr),
      _thread_status(), _thread_name(nullptr),
      _locks(nullptr), _blocker() {
    }
    virtual ~GetThreadSnapshotHandshakeClosure() {

@@ -1325,19 +1324,22 @@
      _methods = new (mtInternal) GrowableArray<Method*>(init_length, mtInternal);
      _bcis = new (mtInternal) GrowableArray<int>(init_length, mtInternal);
      _locks = new (mtInternal) GrowableArray<OwnedLock>(init_length, mtInternal);
      int total_count = 0;
  
+     bool include_monitors = (_include_monitors == JNI_TRUE);
      vframeStream vfst(_java_thread != nullptr
-       ? vframeStream(_java_thread, false, true, vthread_carrier)
+       ? vframeStream(_java_thread, false, include_monitors, vthread_carrier)
        : vframeStream(java_lang_VirtualThread::continuation(_thread_h())));
  
      for (;
        !vfst.at_end() && (max_depth == 0 || max_depth != total_count);
        vfst.next()) {
  
-       detect_locks(vfst.asJavaVFrame(), total_count);
+       if (include_monitors) {
+         detect_locks(vfst.asJavaVFrame(), total_count);
+       }
  
        if (skip_hidden && (vfst.method()->is_hidden() ||
          vfst.method()->is_continuation_enter_intrinsic())) {
          continue;
        }

@@ -1449,11 +1451,11 @@
  int jdk_internal_vm_ThreadSnapshot::_locks_offset;
  int jdk_internal_vm_ThreadSnapshot::_blockerTypeOrdinal_offset;
  int jdk_internal_vm_ThreadSnapshot::_blockerObject_offset;
  int jdk_internal_vm_ThreadSnapshot::_parkBlockerOwner_offset;
  
- oop ThreadSnapshotFactory::get_thread_snapshot(jobject jthread, TRAPS) {
+ oop ThreadSnapshotFactory::get_thread_snapshot(jobject jthread, jboolean include_monitors, TRAPS) {
    ThreadsListHandle tlh(THREAD);
  
    ResourceMark rm(THREAD);
    HandleMark   hm(THREAD);
  

@@ -1467,17 +1469,22 @@
      return nullptr; // thread terminated so not of interest
    }
  
    // Handshake with target
    Handle thread_h(THREAD, thread_oop);
-   GetThreadSnapshotHandshakeClosure cl(thread_h);
+   GetThreadSnapshotHandshakeClosure cl(thread_h, include_monitors);
    if (java_lang_VirtualThread::is_instance(thread_oop)) {
      Handshake::execute(&cl, thread_oop);
    } else {
      Handshake::execute(&cl, &tlh, java_thread);
    }
  
+   // thread not alive
+   if (cl._thread_status == JavaThreadStatus::NEW || cl._thread_status == JavaThreadStatus::TERMINATED) {
+     return nullptr;
+   }
+ 
    // StackTrace
    InstanceKlass* ste_klass = vmClasses::StackTraceElement_klass();
    assert(ste_klass != nullptr, "must be loaded");
  
    objArrayHandle trace = oopFactory::new_objArray_handle(ste_klass, cl._frame_count, CHECK_NULL);

@@ -1503,21 +1510,10 @@
          lock_info->_frame_depth, lock_info->_type, lock_info->_obj, CHECK_NULL);
        locks->obj_at_put(n, lock());
      }
    }
  
-   // call static StackTraceElement[] StackTraceElement.of(StackTraceElement[] stackTrace)
-   // to properly initialize STEs.
-   JavaValue result(T_OBJECT);
-   JavaCalls::call_static(&result,
-     ste_klass,
-     vmSymbols::java_lang_StackTraceElement_of_name(),
-     vmSymbols::java_lang_StackTraceElement_of_signature(),
-     trace,
-     CHECK_NULL);
-   // the method return the same trace array
- 
    Symbol* snapshot_klass_name = vmSymbols::jdk_internal_vm_ThreadSnapshot();
    Klass* snapshot_klass = SystemDictionary::resolve_or_fail(snapshot_klass_name, true, CHECK_NULL);
    if (snapshot_klass->should_be_initialized()) {
      snapshot_klass->initialize(CHECK_NULL);
    }

@@ -1532,7 +1528,5 @@
      jdk_internal_vm_ThreadSnapshot::set_blocker(snapshot(),
          cl._blocker._type, cl._blocker._obj.resolve(), cl._blocker._owner.resolve());
    }
    return snapshot();
  }
- 
- #endif // INCLUDE_JVMTI