1 /*
  2  * Copyright (c) 2003, 2024, Oracle and/or its affiliates. All rights reserved.
  3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  4  *
  5  * This code is free software; you can redistribute it and/or modify it
  6  * under the terms of the GNU General Public License version 2 only, as
  7  * published by the Free Software Foundation.
  8  *
  9  * This code is distributed in the hope that it will be useful, but WITHOUT
 10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 12  * version 2 for more details (a copy is included in the LICENSE file that
 13  * accompanied this code).
 14  *
 15  * You should have received a copy of the GNU General Public License version
 16  * 2 along with this work; if not, write to the Free Software Foundation,
 17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 18  *
 19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 20  * or visit www.oracle.com if you need additional information or have any
 21  * questions.
 22  *
 23  */
 24 
 25 #ifndef SHARE_PRIMS_JVMTIENVBASE_HPP
 26 #define SHARE_PRIMS_JVMTIENVBASE_HPP
 27 
 28 #include "prims/jvmtiEnvThreadState.hpp"
 29 #include "prims/jvmtiEventController.hpp"
 30 #include "prims/jvmtiThreadState.hpp"
 31 #include "oops/oopHandle.hpp"
 32 #include "runtime/atomic.hpp"
 33 #include "runtime/fieldDescriptor.hpp"
 34 #include "runtime/frame.hpp"
 35 #include "runtime/javaThread.hpp"
 36 #include "runtime/threads.hpp"
 37 #include "runtime/vmOperation.hpp"
 38 #include "utilities/growableArray.hpp"
 39 #include "utilities/macros.hpp"
 40 
 41 //
 42 // Forward Declarations
 43 //
 44 
 45 class JvmtiEnv;
 46 class JvmtiThreadState;
 47 class JvmtiRawMonitor; // for jvmtiEnv.hpp
 48 class JvmtiEventControllerPrivate;
 49 class JvmtiTagMap;
 50 
 51 
 52 
 53 // One JvmtiEnv object is created per jvmti attachment;
 54 // done via JNI GetEnv() call. Multiple attachments are
 55 // allowed in jvmti.
 56 
 57 class JvmtiEnvBase : public CHeapObj<mtInternal> {
 58 
 59  private:
 60 
 61 #if INCLUDE_JVMTI
 62   static JvmtiEnvBase*     _head_environment;  // head of environment list
 63 #endif // INCLUDE_JVMTI
 64 
 65   static bool              _globally_initialized;
 66   static jvmtiPhase        _phase;
 67   static volatile int      _dying_thread_env_iteration_count;
 68 
 69  public:
 70 
 71   enum {
 72     JDK15_JVMTI_VERSION = JVMTI_VERSION_1_0 +  33,  /* version: 1.0.33  */
 73     JDK16_JVMTI_VERSION = JVMTI_VERSION_1_1 + 102,  /* version: 1.1.102 */
 74     JDK17_JVMTI_VERSION = JVMTI_VERSION_1_2 +   2   /* version: 1.2.2   */
 75   };
 76 
 77   static jvmtiPhase  get_phase()                    { return _phase; }
 78   static jvmtiPhase  get_phase(jvmtiEnv* env)       { return ((JvmtiEnvBase*)JvmtiEnv_from_jvmti_env(env))->phase(); }
 79   static void  set_phase(jvmtiPhase phase)          { _phase = phase; }
 80   static bool is_vm_live()                          { return _phase == JVMTI_PHASE_LIVE; }
 81 
 82   static void entering_dying_thread_env_iteration() { ++_dying_thread_env_iteration_count; }
 83   static void leaving_dying_thread_env_iteration()  { --_dying_thread_env_iteration_count; }
 84   static bool is_inside_dying_thread_env_iteration(){ return _dying_thread_env_iteration_count > 0; }
 85 
 86   // This function is to support agents loaded into running VM.
 87   static bool enable_virtual_threads_notify_jvmti();
 88 
 89   // This function is used in WhiteBox, only needed to test the function above.
 90   // It is unsafe to use this function when virtual threads are executed.
 91   static bool disable_virtual_threads_notify_jvmti();
 92 
 93   static jvmtiError suspend_thread(oop thread_oop, JavaThread* java_thread, bool single_suspend,
 94                                    int* need_safepoint_p);
 95   static jvmtiError resume_thread(oop thread_oop, JavaThread* java_thread, bool single_resume);
 96   static jvmtiError check_thread_list(jint count, const jthread* list);
 97   static bool is_in_thread_list(jint count, const jthread* list, oop jt_oop);
 98 
 99   // check if thread_oop represents a thread carrying a virtual thread
100   static bool is_thread_carrying_vthread(JavaThread* java_thread, oop thread_oop) {
101     return java_thread != nullptr && java_thread->jvmti_vthread() != nullptr
102                                && java_thread->jvmti_vthread() != thread_oop
103                                && java_thread->threadObj() == thread_oop;
104   }
105 
106  private:
107 
108   enum {
109       JVMTI_MAGIC    = 0x71EE,
110       DISPOSED_MAGIC = 0xDEFC,
111       BAD_MAGIC      = 0xDEAD
112   };
113 
114   jvmtiEnv _jvmti_external;
115   jint _magic;
116   jint _version;  // version value passed to JNI GetEnv()
117   JvmtiEnvBase* _next;
118   bool _is_retransformable;
119   const void *_env_local_storage;     // per env agent allocated data.
120   jvmtiEventCallbacks _event_callbacks;
121   jvmtiExtEventCallbacks _ext_event_callbacks;
122   JvmtiTagMap* volatile _tag_map;
123   JvmtiEnvEventEnable _env_event_enable;
124   jvmtiCapabilities _current_capabilities;
125   jvmtiCapabilities _prohibited_capabilities;
126   volatile bool _class_file_load_hook_ever_enabled;
127   static volatile bool _needs_clean_up;
128   char** _native_method_prefixes;
129   int    _native_method_prefix_count;
130 
131  protected:
132   JvmtiEnvBase(jint version);
133   ~JvmtiEnvBase();
134   void dispose();
135   void env_dispose();
136 
137   void set_env_local_storage(const void* data)     { _env_local_storage = data; }
138 
139   void record_class_file_load_hook_enabled();
140   void record_first_time_class_file_load_hook_enabled();
141 
142   char** get_native_method_prefixes()              { return _native_method_prefixes; }
143   int    get_native_method_prefix_count()          { return _native_method_prefix_count; }
144   jvmtiError set_native_method_prefixes(jint prefix_count, char** prefixes);
145 
146  private:
147   friend class JvmtiEventControllerPrivate;
148   void initialize();
149   void set_event_callbacks(const jvmtiEventCallbacks* callbacks, jint size_of_callbacks);
150   static void globally_initialize();
151   static void periodic_clean_up();
152 
153   friend class JvmtiEnvIterator;
154   JvmtiEnv* next_environment()                     { return (JvmtiEnv*)_next; }
155   void set_next_environment(JvmtiEnvBase* env)     { _next = env; }
156   static JvmtiEnv* head_environment()              {
157     JVMTI_ONLY(return (JvmtiEnv*)_head_environment);
158     NOT_JVMTI(return nullptr);
159   }
160 
161  public:
162 
163   jvmtiPhase  phase();
164   bool is_valid();
165 
166   bool use_version_1_0_semantics();  // agent asked for version 1.0
167   bool use_version_1_1_semantics();  // agent asked for version 1.1
168   bool use_version_1_2_semantics();  // agent asked for version 1.2
169 
170   bool is_retransformable()                        { return _is_retransformable; }
171 
172   const void* get_env_local_storage() { return _env_local_storage; }
173 
174   static ByteSize jvmti_external_offset() {
175     return byte_offset_of(JvmtiEnvBase, _jvmti_external);
176   };
177 
178   // If (thread == nullptr) then return current thread object.
179   // Otherwise return JNIHandles::resolve_external_guard(thread).
180   static oop current_thread_obj_or_resolve_external_guard(jthread thread);
181 
182   // Return true if the thread identified with a pair <jt,thr_obj> is current.
183   // A thread carrying a virtual thread is not treated as current.
184   static bool is_JavaThread_current(JavaThread* jt, oop thr_obj) {
185     JavaThread* current = JavaThread::current();
186     // jt can be null in case of a virtual thread
187     if (jt == nullptr || jt != current) {
188       return false;
189     }
190     oop cur_obj = current->jvmti_vthread();
191 
192     // cur_obj == nullptr is true for normal platform threads only
193     // otherwise it can be virtual or carrier thread.
194     return cur_obj == nullptr || cur_obj == thr_obj;
195   }
196 
197   static jvmtiError get_JavaThread(ThreadsList* tlist, jthread thread, JavaThread** jt_pp) {
198     jvmtiError err = JVMTI_ERROR_NONE;
199     if (thread == nullptr) {
200       *jt_pp = JavaThread::current();
201     } else {
202       err = JvmtiExport::cv_external_thread_to_JavaThread(tlist, thread, jt_pp, nullptr);
203     }
204     return err;
205   }
206 
207   // If there is a virtual thread mounted on the JavaThread* then
208   // return virtual thread oop. Otherwise, return thread oop.
209   static oop get_vthread_or_thread_oop(JavaThread* jt) {
210     oop result = jt->threadObj();
211     if (jt->jvmti_vthread() != nullptr) {
212       result = jt->jvmti_vthread();
213     }
214     return result;
215   }
216 
217   static jvmtiError get_threadOop_and_JavaThread(ThreadsList* t_list, jthread thread, JavaThread* cur_thread,
218                                                  JavaThread** jt_pp, oop* thread_oop_p);
219 
220   // Return true if java thread is a carrier thread with a mounted virtual thread.
221   static bool is_cthread_with_mounted_vthread(JavaThread* jt);
222   static bool is_cthread_with_continuation(JavaThread* jt);
223 
224   // Check if VirtualThread or BoundVirtualThread is suspended.
225   static bool is_vthread_suspended(oop vt_oop, JavaThread* jt);
226 
227   // Check for JVMTI_ERROR_NOT_SUSPENDED and JVMTI_ERROR_OPAQUE_FRAME errors.
228   // Used in PopFrame and ForceEarlyReturn implementations.
229   static jvmtiError check_non_suspended_or_opaque_frame(JavaThread* jt, oop thr_obj, bool self);
230 
231   static JvmtiEnv* JvmtiEnv_from_jvmti_env(jvmtiEnv *env) {
232     return (JvmtiEnv*)((intptr_t)env - in_bytes(jvmti_external_offset()));
233   };
234 
235   jvmtiCapabilities *get_capabilities()             { return &_current_capabilities; }
236 
237   jvmtiCapabilities *get_prohibited_capabilities()  { return &_prohibited_capabilities; }
238 
239   bool early_class_hook_env() {
240     return get_capabilities()->can_generate_early_class_hook_events != 0
241         && get_capabilities()->can_generate_all_class_hook_events != 0;
242   }
243 
244   bool early_vmstart_env() {
245     return get_capabilities()->can_generate_early_vmstart != 0;
246   }
247 
248   static char** get_all_native_method_prefixes(int* count_ptr);
249 
250   // This test will answer true when all environments have been disposed and some have
251   // not yet been deallocated.  As a result, this test should only be used as an
252   // optimization for the no environment case.
253   static bool environments_might_exist() {
254     return head_environment() != nullptr;
255   }
256 
257   static void check_for_periodic_clean_up();
258 
259   JvmtiEnvEventEnable *env_event_enable() {
260     return &_env_event_enable;
261   }
262 
263   jvmtiError allocate(jlong size, unsigned char** mem_ptr) {
264     if (size < 0) {
265       return JVMTI_ERROR_ILLEGAL_ARGUMENT;
266     }
267     if (size == 0) {
268       *mem_ptr = nullptr;
269     } else {
270       *mem_ptr = (unsigned char *)os::malloc((size_t)size, mtInternal);
271       if (*mem_ptr == nullptr) {
272         return JVMTI_ERROR_OUT_OF_MEMORY;
273       }
274     }
275     return JVMTI_ERROR_NONE;
276   }
277 
278   jvmtiError deallocate(unsigned char* mem) {
279     if (mem != nullptr) {
280       os::free(mem);
281     }
282     return JVMTI_ERROR_NONE;
283   }
284 
285 
286   // Memory functions
287   unsigned char* jvmtiMalloc(jlong size);  // don't use this - call allocate
288 
289   // method to create a local handle
290   jobject jni_reference(Handle hndl);
291 
292   // method to create a local handle.
293   // This function allows caller to specify which
294   // threads local handle table to use.
295   jobject jni_reference(JavaThread *thread, Handle hndl);
296 
297   // method to destroy a local handle
298   void destroy_jni_reference(jobject jobj);
299 
300   // method to destroy a local handle.
301   // This function allows caller to specify which
302   // threads local handle table to use.
303   void destroy_jni_reference(JavaThread *thread, jobject jobj);
304 
305   jvmtiEnv* jvmti_external() { return &_jvmti_external; };
306 
307 // Event Dispatch
308 
309   bool has_callback(jvmtiEvent event_type) {
310     assert(event_type >= JVMTI_MIN_EVENT_TYPE_VAL &&
311            event_type <= JVMTI_MAX_EVENT_TYPE_VAL, "checking");
312     return ((void**)&_event_callbacks)[event_type-JVMTI_MIN_EVENT_TYPE_VAL] != nullptr;
313   }
314 
315   jvmtiEventCallbacks* callbacks() {
316     return &_event_callbacks;
317   }
318 
319   jvmtiExtEventCallbacks* ext_callbacks() {
320     return &_ext_event_callbacks;
321   }
322 
323   void set_tag_map(JvmtiTagMap* tag_map) {
324     _tag_map = tag_map;
325   }
326 
327   JvmtiTagMap* tag_map() {
328     return _tag_map;
329   }
330 
331   JvmtiTagMap* tag_map_acquire() {
332     return Atomic::load_acquire(&_tag_map);
333   }
334 
335   void release_set_tag_map(JvmtiTagMap* tag_map) {
336     Atomic::release_store(&_tag_map, tag_map);
337   }
338 
339   // return true if event is enabled globally or for any thread
340   // True only if there is a callback for it.
341   bool is_enabled(jvmtiEvent event_type) {
342     return _env_event_enable.is_enabled(event_type);
343   }
344 
345 // Random Utilities
346 
347  protected:
348   // helper methods for creating arrays of global JNI Handles from local Handles
349   // allocated into environment specific storage
350   jthread * new_jthreadArray(int length, Handle *handles);
351   jthreadGroup * new_jthreadGroupArray(int length, objArrayHandle groups);
352 
353   // convert to a jni jclass from a non-null Klass*
354   jclass get_jni_class_non_null(Klass* k);
355 
356   jint count_locked_objects(JavaThread *java_thread, Handle hobj);
357   jvmtiError get_locked_objects_in_frame(JavaThread *calling_thread,
358                                    JavaThread* java_thread,
359                                    javaVFrame *jvf,
360                                    GrowableArray<jvmtiMonitorStackDepthInfo*>* owned_monitors_list,
361                                    jint depth, oop vthread = nullptr);
362  public:
363   static javaVFrame* jvf_for_thread_and_depth(JavaThread* java_thread, jint depth);
364 
365   // get a field descriptor for the specified class and field
366   static bool get_field_descriptor(Klass* k, jfieldID field, fieldDescriptor* fd);
367 
368   // check and skip frames hidden in mount/unmount transitions
369   static javaVFrame* skip_yield_frames_for_unmounted_vthread(oop vthread, javaVFrame* jvf);
370   static javaVFrame* check_and_skip_hidden_frames(bool is_in_VTMS_transition, javaVFrame* jvf);
371   static javaVFrame* check_and_skip_hidden_frames(JavaThread* jt, javaVFrame* jvf);
372 
373   // check if virtual thread is not terminated (alive)
374   static bool is_vthread_alive(oop vt);
375 
376   // return JavaThread if virtual thread is mounted, null otherwise
377   static JavaThread* get_JavaThread_or_null(oop vthread);
378 
379   // get virtual thread last java vframe
380   static javaVFrame* get_vthread_jvf(oop vthread);
381 
382   // get carrier thread last java vframe
383   static javaVFrame* get_cthread_last_java_vframe(JavaThread* jt, RegisterMap* reg_map);
384 
385   // get platform thread state
386   static jint get_thread_state_base(oop thread_oop, JavaThread* jt);
387   static jint get_thread_state(oop thread_oop, JavaThread* jt);
388 
389   // get virtual thread state
390   static jint get_vthread_state(oop thread_oop, JavaThread* jt);
391 
392   // get platform or virtual thread state
393   static jint get_thread_or_vthread_state(oop thread_oop, JavaThread* jt);
394 
395   // enumerates the live threads in the given thread group
396   static jvmtiError get_live_threads(JavaThread* current_thread, Handle group_hdl, jint *count_ptr, Handle **thread_objs_p);
397 
398   // enumerates the subgroups in the given thread group
399   static jvmtiError get_subgroups(JavaThread* current_thread, Handle group_hdl, jint *count_ptr, objArrayHandle *group_objs_p);
400 
401   // JVMTI API helper functions which are called when target thread is suspended
402   // or at safepoint / thread local handshake.
403   static jint get_frame_count(javaVFrame* jvf);
404   jvmtiError get_frame_count(JavaThread* java_thread, jint *count_ptr);
405   jvmtiError get_frame_count(oop frame_oop, jint *count_ptr);
406   jvmtiError get_frame_location(javaVFrame* jvf, jint depth,
407                                 jmethodID* method_ptr, jlocation* location_ptr);
408   jvmtiError get_frame_location(JavaThread* java_thread, jint depth,
409                                 jmethodID* method_ptr, jlocation* location_ptr);
410   jvmtiError get_frame_location(oop vthread_oop, jint depth,
411                                 jmethodID* method_ptr, jlocation* location_ptr);
412   jvmtiError set_frame_pop(JvmtiThreadState* state, javaVFrame* jvf, jint depth);
413   jvmtiError get_object_monitor_usage(JavaThread* calling_thread,
414                                       jobject object, jvmtiMonitorUsage* info_ptr);
415   jvmtiError get_stack_trace(javaVFrame* jvf,
416                              jint stack_depth, jint max_count,
417                              jvmtiFrameInfo* frame_buffer, jint* count_ptr);
418   jvmtiError get_stack_trace(JavaThread* java_thread,
419                              jint stack_depth, jint max_count,
420                              jvmtiFrameInfo* frame_buffer, jint* count_ptr);
421   jvmtiError get_current_contended_monitor(JavaThread* calling_thread, JavaThread* java_thread,
422                                            jobject* monitor_ptr, bool is_virtual);
423   jvmtiError get_owned_monitors(JavaThread* calling_thread, JavaThread* java_thread,
424                                 GrowableArray<jvmtiMonitorStackDepthInfo*> *owned_monitors_list);
425   jvmtiError get_owned_monitors(JavaThread* calling_thread, JavaThread* carrier, javaVFrame* jvf,
426                                 GrowableArray<jvmtiMonitorStackDepthInfo*> *owned_monitors_list, oop vthread);
427   static jvmtiError check_top_frame(Thread* current_thread, JavaThread* java_thread,
428                                     jvalue value, TosState tos, Handle* ret_ob_h);
429   jvmtiError force_early_return(jthread thread, jvalue value, TosState tos);
430 };
431 
432 // This class is the only safe means of iterating through environments.
433 // Note that this iteratation includes invalid environments pending
434 // deallocation -- in fact, some uses depend on this behavior.
435 
436 class JvmtiEnvIterator : public StackObj {
437  private:
438   bool _entry_was_marked;
439  public:
440   JvmtiEnvIterator() {
441     if (Threads::number_of_threads() == 0) {
442       _entry_was_marked = false; // we are single-threaded, no need
443     } else {
444       Thread::current()->entering_jvmti_env_iteration();
445       _entry_was_marked = true;
446     }
447   }
448   ~JvmtiEnvIterator() {
449     if (_entry_was_marked) {
450       Thread::current()->leaving_jvmti_env_iteration();
451     }
452   }
453   JvmtiEnv* first()                 { return JvmtiEnvBase::head_environment(); }
454   JvmtiEnv* next(JvmtiEnvBase* env) { return env->next_environment(); }
455 };
456 
457 // Used in combination with the JvmtiHandshake class.
458 // It is intended to support both platform and virtual threads.
459 class JvmtiUnitedHandshakeClosure : public HandshakeClosure {
460  protected:
461   jvmtiError _result;
462   // the fields below are set by the JvmtiHandshake::execute
463   JavaThread* _target_jt;
464   bool _is_virtual;
465   bool _self;
466  public:
467   JvmtiUnitedHandshakeClosure(const char* name)
468     : HandshakeClosure(name),
469       _result(JVMTI_ERROR_THREAD_NOT_ALIVE),
470       _target_jt(nullptr),
471       _is_virtual(false),
472       _self(false) {}
473 
474   void set_result(jvmtiError err) { _result = err; }
475   void set_target_jt(JavaThread* target_jt) { _target_jt = target_jt; }
476   void set_is_virtual(bool val) { _is_virtual = val; }
477   void set_self(bool val) { _self = val; }
478   jvmtiError result() { return _result; }
479   virtual void do_vthread(Handle target_h) = 0;
480 };
481 
482 // The JvmtiHandshake supports virtual threads.
483 class JvmtiHandshake : public Handshake {
484  public:
485   static void execute(JvmtiUnitedHandshakeClosure* hs_cl, ThreadsListHandle* tlh,
486                       JavaThread* target_jt, Handle target_h);
487   static void execute(JvmtiUnitedHandshakeClosure* hs_cl, jthread target);
488 };
489 
490 class SetForceEarlyReturn : public JvmtiUnitedHandshakeClosure {
491 private:
492   JvmtiThreadState* _state;
493   jvalue _value;
494   TosState _tos;
495 public:
496   SetForceEarlyReturn(JvmtiThreadState* state, jvalue value, TosState tos)
497     : JvmtiUnitedHandshakeClosure("SetForceEarlyReturn"),
498      _state(state),
499      _value(value),
500      _tos(tos) {}
501   void doit(Thread *target);
502   void do_thread(Thread *target) {
503     doit(target);
504   }
505   void do_vthread(Handle target_h) {
506     assert(_target_jt != nullptr, "sanity check");
507     // Use jvmti_vthread() instead of vthread() as target could have temporarily changed
508     // identity to carrier thread (see VirtualThread.switchToCarrierThread).
509     assert(_target_jt->jvmti_vthread() == target_h(), "sanity check");
510     doit(_target_jt); // mounted virtual thread
511   }
512 };
513 
514 // HandshakeClosure to update for pop top frame.
515 class UpdateForPopTopFrameClosure : public JvmtiUnitedHandshakeClosure {
516 private:
517   JvmtiThreadState* _state;
518 
519 public:
520   UpdateForPopTopFrameClosure(JvmtiThreadState* state)
521     : JvmtiUnitedHandshakeClosure("UpdateForPopTopFrame"),
522      _state(state) {}
523   void doit(Thread *target);
524   void do_thread(Thread *target) {
525     doit(target);
526   }
527   void do_vthread(Handle target_h) {
528     assert(_target_jt != nullptr, "sanity check");
529     // Use jvmti_vthread() instead of vthread() as target could have temporarily changed
530     // identity to carrier thread (see VirtualThread.switchToCarrierThread).
531     assert(_target_jt->jvmti_vthread() == target_h(), "sanity check");
532     doit(_target_jt); // mounted virtual thread
533   }
534 };
535 
536 // HandshakeClosure to set frame pop.
537 class SetFramePopClosure : public JvmtiUnitedHandshakeClosure {
538 private:
539   JvmtiEnv *_env;
540   JvmtiThreadState* _state;
541   jint _depth;
542 
543 public:
544   SetFramePopClosure(JvmtiEnv *env, JvmtiThreadState* state, jint depth)
545     : JvmtiUnitedHandshakeClosure("SetFramePopClosure"),
546       _env(env),
547       _state(state),
548       _depth(depth) {}
549   void do_thread(Thread *target);
550   void do_vthread(Handle target_h);
551 };
552 
553 // HandshakeClosure to get monitor information with stack depth.
554 class GetOwnedMonitorInfoClosure : public JvmtiUnitedHandshakeClosure {
555 private:
556   JvmtiEnv *_env;
557   JavaThread* _calling_thread;
558   GrowableArray<jvmtiMonitorStackDepthInfo*> *_owned_monitors_list;
559 
560 public:
561   GetOwnedMonitorInfoClosure(JvmtiEnv* env,
562                              JavaThread* calling_thread,
563                              GrowableArray<jvmtiMonitorStackDepthInfo*>* owned_monitors_list)
564     : JvmtiUnitedHandshakeClosure("GetOwnedMonitorInfo"),
565       _env(env),
566       _calling_thread(calling_thread),
567       _owned_monitors_list(owned_monitors_list) {}
568 
569   void do_thread(Thread *target);
570   void do_vthread(Handle target_h);
571 };
572 
573 // VM operation to get object monitor usage.
574 class VM_GetObjectMonitorUsage : public VM_Operation {
575 private:
576   JvmtiEnv *_env;
577   jobject _object;
578   JavaThread* _calling_thread;
579   jvmtiMonitorUsage* _info_ptr;
580   jvmtiError _result;
581 
582 public:
583   VM_GetObjectMonitorUsage(JvmtiEnv *env, JavaThread* calling_thread, jobject object, jvmtiMonitorUsage* info_ptr) {
584     _env = env;
585     _object = object;
586     _calling_thread = calling_thread;
587     _info_ptr = info_ptr;
588   }
589   VMOp_Type type() const { return VMOp_GetObjectMonitorUsage; }
590   jvmtiError result() { return _result; }
591   void doit() {
592     _result = ((JvmtiEnvBase*) _env)->get_object_monitor_usage(_calling_thread, _object, _info_ptr);
593   }
594 
595 };
596 
597 // HandshakeClosure to get current contended monitor. It is used for both platform and virtual threads.
598 class GetCurrentContendedMonitorClosure : public JvmtiUnitedHandshakeClosure {
599 private:
600   JvmtiEnv *_env;
601   JavaThread *_calling_thread;
602   jobject *_owned_monitor_ptr;
603 
604 public:
605   GetCurrentContendedMonitorClosure(JvmtiEnv *env,
606                                     JavaThread* calling_thread,
607                                     jobject *owned_monitor_ptr)
608     : JvmtiUnitedHandshakeClosure("GetCurrentContendedMonitor"),
609       _env(env),
610       _calling_thread(calling_thread),
611       _owned_monitor_ptr(owned_monitor_ptr) {}
612   void do_thread(Thread *target);
613   void do_vthread(Handle target_h);
614 };
615 
616 // HandshakeClosure to get stack trace.
617 class GetStackTraceClosure : public JvmtiUnitedHandshakeClosure {
618 private:
619   JvmtiEnv *_env;
620   jint _start_depth;
621   jint _max_count;
622   jvmtiFrameInfo *_frame_buffer;
623   jint *_count_ptr;
624 
625 public:
626   GetStackTraceClosure(JvmtiEnv *env, jint start_depth, jint max_count,
627                        jvmtiFrameInfo* frame_buffer, jint* count_ptr)
628     : JvmtiUnitedHandshakeClosure("GetStackTrace"),
629       _env(env),
630       _start_depth(start_depth),
631       _max_count(max_count),
632       _frame_buffer(frame_buffer),
633       _count_ptr(count_ptr) {}
634   void do_thread(Thread *target);
635   void do_vthread(Handle target_h);
636 };
637 
638 #ifdef ASSERT
639 // HandshakeClosure to print stack trace in JvmtiVTMSTransitionDisabler error handling.
640 class PrintStackTraceClosure : public HandshakeClosure {
641  public:
642   static void do_thread_impl(Thread *target);
643 
644   PrintStackTraceClosure()
645       : HandshakeClosure("PrintStackTraceClosure") {}
646   void do_thread(Thread *target);
647 };
648 #endif
649 
650 // Forward declaration.
651 struct StackInfoNode;
652 
653 // Get stack trace at safepoint or at direct handshake.
654 class MultipleStackTracesCollector {
655 private:
656   friend class VM_GetThreadListStackTraces;
657   JvmtiEnv *_env;
658   jint _max_frame_count;
659   jvmtiStackInfo *_stack_info;
660   jvmtiError _result;
661   int _frame_count_total;
662   struct StackInfoNode *_head;
663 
664   JvmtiEnvBase *env()                 { return (JvmtiEnvBase *)_env; }
665   jint max_frame_count()              { return _max_frame_count; }
666   struct StackInfoNode *head()        { return _head; }
667   void set_head(StackInfoNode *head)  { _head = head; }
668 
669 public:
670   MultipleStackTracesCollector(JvmtiEnv *env, jint max_frame_count)
671     : _env(env),
672       _max_frame_count(max_frame_count),
673       _stack_info(nullptr),
674       _result(JVMTI_ERROR_NONE),
675       _frame_count_total(0),
676       _head(nullptr) {
677   }
678   void set_result(jvmtiError result)  { _result = result; }
679   void fill_frames(jthread jt, JavaThread *thr, oop thread_oop);
680   void allocate_and_fill_stacks(jint thread_count);
681   jvmtiStackInfo *stack_info()       { return _stack_info; }
682   jvmtiError result()                { return _result; }
683 };
684 
685 
686 // VM operation to get stack trace at safepoint.
687 class VM_GetAllStackTraces : public VM_Operation {
688 private:
689   JavaThread *_calling_thread;
690   jint _final_thread_count;
691   MultipleStackTracesCollector _collector;
692 
693 public:
694   VM_GetAllStackTraces(JvmtiEnv *env, JavaThread *calling_thread,
695                        jint max_frame_count)
696       : _calling_thread(calling_thread),
697         _final_thread_count(0),
698         _collector(env, max_frame_count) {
699   }
700   VMOp_Type type() const          { return VMOp_GetAllStackTraces; }
701   void doit();
702   jint final_thread_count()       { return _final_thread_count; }
703   jvmtiStackInfo *stack_info()    { return _collector.stack_info(); }
704   jvmtiError result()             { return _collector.result(); }
705 };
706 
707 // VM operation to get stack trace at safepoint.
708 class VM_GetThreadListStackTraces : public VM_Operation {
709 private:
710   jint _thread_count;
711   const jthread* _thread_list;
712   MultipleStackTracesCollector _collector;
713 
714   JvmtiEnvBase *env() { return _collector.env(); }
715 
716 public:
717   VM_GetThreadListStackTraces(JvmtiEnv *env, jint thread_count, const jthread* thread_list, jint max_frame_count)
718       : _thread_count(thread_count),
719         _thread_list(thread_list),
720         _collector(env, max_frame_count) {
721   }
722   VMOp_Type type() const { return VMOp_GetThreadListStackTraces; }
723   void doit();
724   jvmtiStackInfo *stack_info()    { return _collector.stack_info(); }
725   jvmtiError result()             { return _collector.result(); }
726 };
727 
728 // HandshakeClosure to get single stack trace.
729 class GetSingleStackTraceClosure : public JvmtiUnitedHandshakeClosure {
730 private:
731   JavaThread *_calling_thread;
732   jthread _jthread;
733   MultipleStackTracesCollector _collector;
734 
735 public:
736   GetSingleStackTraceClosure(JvmtiEnv *env, JavaThread *calling_thread,
737                              jthread thread, jint max_frame_count)
738     : JvmtiUnitedHandshakeClosure("GetSingleStackTrace"),
739       _calling_thread(calling_thread),
740       _jthread(thread),
741       _collector(env, max_frame_count) {
742   }
743   void do_thread(Thread *target);
744   void do_vthread(Handle target_h);
745   void doit();
746   jvmtiStackInfo *stack_info()    { return _collector.stack_info(); }
747   jvmtiError result()             { return _result; }
748 };
749 
750 // HandshakeClosure to count stack frames.
751 class GetFrameCountClosure : public JvmtiUnitedHandshakeClosure {
752 private:
753   JvmtiEnv *_env;
754   jint *_count_ptr;
755 
756 public:
757   GetFrameCountClosure(JvmtiEnv *env, jint *count_ptr)
758     : JvmtiUnitedHandshakeClosure("GetFrameCount"),
759       _env(env),
760       _count_ptr(count_ptr) {}
761   void do_thread(Thread *target);
762   void do_vthread(Handle target_h);
763 };
764 
765 // HandshakeClosure to get frame location.
766 class GetFrameLocationClosure : public JvmtiUnitedHandshakeClosure {
767 private:
768   JvmtiEnv *_env;
769   jint _depth;
770   jmethodID* _method_ptr;
771   jlocation* _location_ptr;
772 
773 public:
774   GetFrameLocationClosure(JvmtiEnv *env, jint depth,
775                           jmethodID* method_ptr, jlocation* location_ptr)
776     : JvmtiUnitedHandshakeClosure("GetFrameLocation"),
777       _env(env),
778       _depth(depth),
779       _method_ptr(method_ptr),
780       _location_ptr(location_ptr) {}
781   void do_thread(Thread *target);
782   void do_vthread(Handle target_h);
783 };
784 
785 // ResourceTracker
786 //
787 // ResourceTracker works a little like a ResourceMark. All allocates
788 // using the resource tracker are recorded. If an allocate using the
789 // resource tracker fails the destructor will free any resources
790 // that were allocated using the tracker.
791 // The motive for this class is to avoid messy error recovery code
792 // in situations where multiple allocations are done in sequence. If
793 // the second or subsequent allocation fails it avoids any code to
794 // release memory allocated in the previous calls.
795 //
796 // Usage :-
797 //   ResourceTracker rt(env);
798 //   :
799 //   err = rt.allocate(1024, &ptr);
800 
801 class ResourceTracker : public StackObj {
802  private:
803   JvmtiEnv* _env;
804   GrowableArray<unsigned char*> *_allocations;
805   bool _failed;
806  public:
807   ResourceTracker(JvmtiEnv* env);
808   ~ResourceTracker();
809   jvmtiError allocate(jlong size, unsigned char** mem_ptr);
810   unsigned char* allocate(jlong size);
811   char* strdup(const char* str);
812 };
813 
814 
815 // Jvmti monitor closure to collect off stack monitors.
816 class JvmtiMonitorClosure: public MonitorClosure {
817  private:
818   JavaThread *_calling_thread;
819   GrowableArray<jvmtiMonitorStackDepthInfo*> *_owned_monitors_list;
820   jvmtiError _error;
821   JvmtiEnvBase *_env;
822 
823  public:
824   JvmtiMonitorClosure(JavaThread *calling_thread,
825                       GrowableArray<jvmtiMonitorStackDepthInfo*> *owned_monitors,
826                       JvmtiEnvBase *env) {
827     _calling_thread = calling_thread;
828     _owned_monitors_list = owned_monitors;
829     _error = JVMTI_ERROR_NONE;
830     _env = env;
831   }
832   void do_monitor(ObjectMonitor* mon);
833   jvmtiError error() { return _error;}
834 };
835 
836 
837 // Jvmti module closure to collect all modules loaded to the system.
838 class JvmtiModuleClosure : public StackObj {
839 private:
840   static GrowableArray<OopHandle> *_tbl; // Protected with Module_lock
841 
842   static void do_module(ModuleEntry* entry);
843 public:
844   jvmtiError get_all_modules(JvmtiEnv* env, jint* module_count_ptr, jobject** modules_ptr);
845 };
846 
847 #endif // SHARE_PRIMS_JVMTIENVBASE_HPP