1 /*
  2  * Copyright (c) 1997, 2021, 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_RUNTIME_VMOPERATION_HPP
 26 #define SHARE_RUNTIME_VMOPERATION_HPP
 27 
 28 #include "memory/allocation.hpp"
 29 
 30 // The following classes are used for operations
 31 // initiated by a Java thread but that must
 32 // take place in the VMThread.
 33 
 34 #define VM_OP_ENUM(type)   VMOp_##type,
 35 
 36 // Note: When new VM_XXX comes up, add 'XXX' to the template table.
 37 #define VM_OPS_DO(template)                       \
 38   template(None)                                  \
 39   template(Cleanup)                               \
 40   template(ThreadDump)                            \
 41   template(PrintThreads)                          \
 42   template(FindDeadlocks)                         \
 43   template(ClearICs)                              \
 44   template(ForceSafepoint)                        \
 45   template(ForceAsyncSafepoint)                   \
 46   template(DeoptimizeFrame)                       \
 47   template(DeoptimizeAll)                         \
 48   template(ZombieAll)                             \
 49   template(Verify)                                \
 50   template(PrintJNI)                              \
 51   template(HeapDumper)                            \
 52   template(DeoptimizeTheWorld)                    \
 53   template(CollectForMetadataAllocation)          \
 54   template(GC_HeapInspection)                     \
 55   template(GenCollectFull)                        \
 56   template(GenCollectFullConcurrent)              \
 57   template(GenCollectForAllocation)               \
 58   template(ParallelGCFailedAllocation)            \
 59   template(ParallelGCSystemGC)                    \
 60   template(G1CollectForAllocation)                \
 61   template(G1CollectFull)                         \
 62   template(G1Concurrent)                          \
 63   template(G1TryInitiateConcMark)                 \
 64   template(ZMarkStart)                            \
 65   template(ZMarkEnd)                              \
 66   template(ZRelocateStart)                        \
 67   template(ZVerify)                               \
 68   template(HandshakeOneThread)                    \
 69   template(HandshakeAllThreads)                   \
 70   template(HandshakeFallback)                     \
 71   template(EnableBiasedLocking)                   \
 72   template(BulkRevokeBias)                        \
 73   template(PopulateDumpSharedSpace)               \
 74   template(JNIFunctionTableCopier)                \
 75   template(RedefineClasses)                       \
 76   template(GetObjectMonitorUsage)                 \
 77   template(GetAllStackTraces)                     \
 78   template(GetThreadListStackTraces)              \
 79   template(ChangeBreakpoints)                     \
 80   template(GetOrSetLocal)                         \
 81   template(ChangeSingleStep)                      \
 82   template(HeapWalkOperation)                     \
 83   template(HeapIterateOperation)                  \
 84   template(HeapObjectStatistics)                  \
 85   template(ReportJavaOutOfMemory)                 \
 86   template(JFRCheckpoint)                         \
 87   template(ShenandoahFullGC)                      \
 88   template(ShenandoahInitMark)                    \
 89   template(ShenandoahFinalMarkStartEvac)          \
 90   template(ShenandoahInitUpdateRefs)              \
 91   template(ShenandoahFinalUpdateRefs)             \
 92   template(ShenandoahFinalRoots)                  \
 93   template(ShenandoahDegeneratedGC)               \
 94   template(RendezvousGCThreads)                   \
 95   template(Exit)                                  \
 96   template(LinuxDllLoad)                          \
 97   template(RotateGCLog)                           \
 98   template(WhiteBoxOperation)                     \
 99   template(JVMCIResizeCounters)                   \
100   template(ClassLoaderStatsOperation)             \
101   template(ClassLoaderHierarchyOperation)         \
102   template(DumpHashtable)                         \
103   template(DumpTouchedMethods)                    \
104   template(CleanClassLoaderDataMetaspaces)        \
105   template(PrintCompileQueue)                     \
106   template(PrintClassHierarchy)                   \
107   template(ThreadSuspend)                         \
108   template(ThreadsSuspendJVMTI)                   \
109   template(ICBufferFull)                          \
110   template(ScavengeMonitors)                      \
111   template(PrintMetadata)                         \
112   template(GTestExecuteAtSafepoint)               \
113   template(JFROldObject)                          \
114   template(JvmtiPostObjectFree)
115 
116 class Thread;
117 class outputStream;
118 
119 class VM_Operation : public StackObj {
120  public:
121   enum VMOp_Type {
122     VM_OPS_DO(VM_OP_ENUM)
123     VMOp_Terminating
124   };
125 
126  private:
127   Thread*         _calling_thread;
128 
129   // The VM operation name array
130   static const char* _names[];
131 
132  public:
133   VM_Operation() : _calling_thread(NULL) {}
134 
135   // VM operation support (used by VM thread)
136   Thread* calling_thread() const                 { return _calling_thread; }
137   void set_calling_thread(Thread* thread);
138 
139   // Called by VM thread - does in turn invoke doit(). Do not override this
140   void evaluate();
141 
142   // evaluate() is called by the VMThread and in turn calls doit().
143   // If the thread invoking VMThread::execute((VM_Operation*) is a JavaThread,
144   // doit_prologue() is called in that thread before transferring control to
145   // the VMThread.
146   // If doit_prologue() returns true the VM operation will proceed, and
147   // doit_epilogue() will be called by the JavaThread once the VM operation
148   // completes. If doit_prologue() returns false the VM operation is cancelled.
149   virtual void doit()                            = 0;
150   virtual bool doit_prologue()                   { return true; };
151   virtual void doit_epilogue()                   {};
152 
153   // Configuration. Override these appropriately in subclasses.
154   virtual VMOp_Type type() const = 0;
155   virtual bool allow_nested_vm_operations() const { return false; }
156 
157   // You may override skip_thread_oop_barriers to return true if the operation
158   // does not access thread-private oops (including frames).
159   virtual bool skip_thread_oop_barriers() const { return false; }
160 
161   // An operation can either be done inside a safepoint
162   // or concurrently with Java threads running.
163   virtual bool evaluate_at_safepoint() const { return true; }
164 
165   // Debugging
166   virtual void print_on_error(outputStream* st) const;
167   virtual const char* name() const  { return _names[type()]; }
168   static const char* name(int type) {
169     assert(type >= 0 && type < VMOp_Terminating, "invalid VM operation type");
170     return _names[type];
171   }
172 #ifndef PRODUCT
173   void print_on(outputStream* st) const { print_on_error(st); }
174 #endif
175 };
176 
177 #endif // SHARE_RUNTIME_VMOPERATION_HPP