src/share/vm/services/diagnosticCommand.hpp

changeset 5047
31a4e55f8c9d
parent 4544
3c9bc17b9403
child 5968
996d1f2f056f
equal deleted inserted replaced
4999:8fe2542bdc8d 5047:31a4e55f8c9d
49 "With no argument this will show a list of available commands. " 49 "With no argument this will show a list of available commands. "
50 "'help all' will show help for all commands."; 50 "'help all' will show help for all commands.";
51 } 51 }
52 static const char* impact() { return "Low"; } 52 static const char* impact() { return "Low"; }
53 static int num_arguments(); 53 static int num_arguments();
54 virtual void execute(TRAPS); 54 virtual void execute(DCmdSource source, TRAPS);
55 }; 55 };
56 56
57 class VersionDCmd : public DCmd { 57 class VersionDCmd : public DCmd {
58 public: 58 public:
59 VersionDCmd(outputStream* output, bool heap) : DCmd(output,heap) { } 59 VersionDCmd(outputStream* output, bool heap) : DCmd(output,heap) { }
60 static const char* name() { return "VM.version"; } 60 static const char* name() { return "VM.version"; }
61 static const char* description() { 61 static const char* description() {
62 return "Print JVM version information."; 62 return "Print JVM version information.";
63 } 63 }
64 static const char* impact() { return "Low"; } 64 static const char* impact() { return "Low"; }
65 static const JavaPermission permission() {
66 JavaPermission p = {"java.util.PropertyPermission",
67 "java.vm.version", "read"};
68 return p;
69 }
65 static int num_arguments() { return 0; } 70 static int num_arguments() { return 0; }
66 virtual void execute(TRAPS); 71 virtual void execute(DCmdSource source, TRAPS);
67 }; 72 };
68 73
69 class CommandLineDCmd : public DCmd { 74 class CommandLineDCmd : public DCmd {
70 public: 75 public:
71 CommandLineDCmd(outputStream* output, bool heap) : DCmd(output, heap) { } 76 CommandLineDCmd(outputStream* output, bool heap) : DCmd(output, heap) { }
72 static const char* name() { return "VM.command_line"; } 77 static const char* name() { return "VM.command_line"; }
73 static const char* description() { 78 static const char* description() {
74 return "Print the command line used to start this VM instance."; 79 return "Print the command line used to start this VM instance.";
75 } 80 }
76 static const char* impact() { return "Low"; } 81 static const char* impact() { return "Low"; }
82 static const JavaPermission permission() {
83 JavaPermission p = {"java.lang.management.ManagementPermission",
84 "monitor", NULL};
85 return p;
86 }
77 static int num_arguments() { return 0; } 87 static int num_arguments() { return 0; }
78 virtual void execute(TRAPS) { 88 virtual void execute(DCmdSource source, TRAPS) {
79 Arguments::print_on(_output); 89 Arguments::print_on(_output);
80 } 90 }
81 }; 91 };
82 92
83 // See also: get_system_properties in attachListener.cpp 93 // See also: get_system_properties in attachListener.cpp
89 return "Print system properties."; 99 return "Print system properties.";
90 } 100 }
91 static const char* impact() { 101 static const char* impact() {
92 return "Low"; 102 return "Low";
93 } 103 }
104 static const JavaPermission permission() {
105 JavaPermission p = {"java.util.PropertyPermission",
106 "*", "read"};
107 return p;
108 }
94 static int num_arguments() { return 0; } 109 static int num_arguments() { return 0; }
95 virtual void execute(TRAPS); 110 virtual void execute(DCmdSource source, TRAPS);
96 }; 111 };
97 112
98 // See also: print_flag in attachListener.cpp 113 // See also: print_flag in attachListener.cpp
99 class PrintVMFlagsDCmd : public DCmdWithParser { 114 class PrintVMFlagsDCmd : public DCmdWithParser {
100 protected: 115 protected:
106 return "Print VM flag options and their current values."; 121 return "Print VM flag options and their current values.";
107 } 122 }
108 static const char* impact() { 123 static const char* impact() {
109 return "Low"; 124 return "Low";
110 } 125 }
111 static int num_arguments(); 126 static const JavaPermission permission() {
112 virtual void execute(TRAPS); 127 JavaPermission p = {"java.lang.management.ManagementPermission",
128 "monitor", NULL};
129 return p;
130 }
131 static int num_arguments();
132 virtual void execute(DCmdSource source, TRAPS);
113 }; 133 };
114 134
115 class VMUptimeDCmd : public DCmdWithParser { 135 class VMUptimeDCmd : public DCmdWithParser {
116 protected: 136 protected:
117 DCmdArgument<bool> _date; 137 DCmdArgument<bool> _date;
123 } 143 }
124 static const char* impact() { 144 static const char* impact() {
125 return "Low"; 145 return "Low";
126 } 146 }
127 static int num_arguments(); 147 static int num_arguments();
128 virtual void execute(TRAPS); 148 virtual void execute(DCmdSource source, TRAPS);
129 }; 149 };
130 150
131 class SystemGCDCmd : public DCmd { 151 class SystemGCDCmd : public DCmd {
132 public: 152 public:
133 SystemGCDCmd(outputStream* output, bool heap) : DCmd(output, heap) { } 153 SystemGCDCmd(outputStream* output, bool heap) : DCmd(output, heap) { }
137 } 157 }
138 static const char* impact() { 158 static const char* impact() {
139 return "Medium: Depends on Java heap size and content."; 159 return "Medium: Depends on Java heap size and content.";
140 } 160 }
141 static int num_arguments() { return 0; } 161 static int num_arguments() { return 0; }
142 virtual void execute(TRAPS); 162 virtual void execute(DCmdSource source, TRAPS);
143 }; 163 };
144 164
145 class RunFinalizationDCmd : public DCmd { 165 class RunFinalizationDCmd : public DCmd {
146 public: 166 public:
147 RunFinalizationDCmd(outputStream* output, bool heap) : DCmd(output, heap) { } 167 RunFinalizationDCmd(outputStream* output, bool heap) : DCmd(output, heap) { }
151 } 171 }
152 static const char* impact() { 172 static const char* impact() {
153 return "Medium: Depends on Java content."; 173 return "Medium: Depends on Java content.";
154 } 174 }
155 static int num_arguments() { return 0; } 175 static int num_arguments() { return 0; }
156 virtual void execute(TRAPS); 176 virtual void execute(DCmdSource source, TRAPS);
157 }; 177 };
158 178
159 #if INCLUDE_SERVICES // Heap dumping supported 179 #if INCLUDE_SERVICES // Heap dumping supported
160 // See also: dump_heap in attachListener.cpp 180 // See also: dump_heap in attachListener.cpp
161 class HeapDumpDCmd : public DCmdWithParser { 181 class HeapDumpDCmd : public DCmdWithParser {
172 } 192 }
173 static const char* impact() { 193 static const char* impact() {
174 return "High: Depends on Java heap size and content. " 194 return "High: Depends on Java heap size and content. "
175 "Request a full GC unless the '-all' option is specified."; 195 "Request a full GC unless the '-all' option is specified.";
176 } 196 }
177 static int num_arguments(); 197 static const JavaPermission permission() {
178 virtual void execute(TRAPS); 198 JavaPermission p = {"java.lang.management.ManagementPermission",
199 "monitor", NULL};
200 return p;
201 }
202 static int num_arguments();
203 virtual void execute(DCmdSource source, TRAPS);
179 }; 204 };
180 #endif // INCLUDE_SERVICES 205 #endif // INCLUDE_SERVICES
181 206
182 // See also: inspectheap in attachListener.cpp 207 // See also: inspectheap in attachListener.cpp
183 class ClassHistogramDCmd : public DCmdWithParser { 208 class ClassHistogramDCmd : public DCmdWithParser {
192 return "Provide statistics about the Java heap usage."; 217 return "Provide statistics about the Java heap usage.";
193 } 218 }
194 static const char* impact() { 219 static const char* impact() {
195 return "High: Depends on Java heap size and content."; 220 return "High: Depends on Java heap size and content.";
196 } 221 }
197 static int num_arguments(); 222 static const JavaPermission permission() {
198 virtual void execute(TRAPS); 223 JavaPermission p = {"java.lang.management.ManagementPermission",
224 "monitor", NULL};
225 return p;
226 }
227 static int num_arguments();
228 virtual void execute(DCmdSource source, TRAPS);
199 }; 229 };
200 230
201 class ClassStatsDCmd : public DCmdWithParser { 231 class ClassStatsDCmd : public DCmdWithParser {
202 protected: 232 protected:
203 DCmdArgument<bool> _all; 233 DCmdArgument<bool> _all;
214 } 244 }
215 static const char* impact() { 245 static const char* impact() {
216 return "High: Depends on Java heap size and content."; 246 return "High: Depends on Java heap size and content.";
217 } 247 }
218 static int num_arguments(); 248 static int num_arguments();
219 virtual void execute(TRAPS); 249 virtual void execute(DCmdSource source, TRAPS);
220 }; 250 };
221 251
222 // See also: thread_dump in attachListener.cpp 252 // See also: thread_dump in attachListener.cpp
223 class ThreadDumpDCmd : public DCmdWithParser { 253 class ThreadDumpDCmd : public DCmdWithParser {
224 protected: 254 protected:
230 return "Print all threads with stacktraces."; 260 return "Print all threads with stacktraces.";
231 } 261 }
232 static const char* impact() { 262 static const char* impact() {
233 return "Medium: Depends on the number of threads."; 263 return "Medium: Depends on the number of threads.";
234 } 264 }
235 static int num_arguments(); 265 static const JavaPermission permission() {
236 virtual void execute(TRAPS); 266 JavaPermission p = {"java.lang.management.ManagementPermission",
267 "monitor", NULL};
268 return p;
269 }
270 static int num_arguments();
271 virtual void execute(DCmdSource source, TRAPS);
237 }; 272 };
238 273
239 // Enhanced JMX Agent support 274 // Enhanced JMX Agent support
240 275
241 class JMXStartRemoteDCmd : public DCmdWithParser { 276 class JMXStartRemoteDCmd : public DCmdWithParser {
279 return "Start remote management agent."; 314 return "Start remote management agent.";
280 } 315 }
281 316
282 static int num_arguments(); 317 static int num_arguments();
283 318
284 virtual void execute(TRAPS); 319 virtual void execute(DCmdSource source, TRAPS);
285 320
286 }; 321 };
287 322
288 class JMXStartLocalDCmd : public DCmd { 323 class JMXStartLocalDCmd : public DCmd {
289 324
300 335
301 static const char *description() { 336 static const char *description() {
302 return "Start local management agent."; 337 return "Start local management agent.";
303 } 338 }
304 339
305 virtual void execute(TRAPS); 340 virtual void execute(DCmdSource source, TRAPS);
306 341
307 }; 342 };
308 343
309 class JMXStopRemoteDCmd : public DCmd { 344 class JMXStopRemoteDCmd : public DCmd {
310 public: 345 public:
319 354
320 static const char *description() { 355 static const char *description() {
321 return "Stop remote management agent."; 356 return "Stop remote management agent.";
322 } 357 }
323 358
324 virtual void execute(TRAPS); 359 virtual void execute(DCmdSource source, TRAPS);
325 }; 360 };
326 361
327 #endif // SHARE_VM_SERVICES_DIAGNOSTICCOMMAND_HPP 362 #endif // SHARE_VM_SERVICES_DIAGNOSTICCOMMAND_HPP

mercurial