33 #include "runtime/os.hpp"
34 #include "services/diagnosticArgument.hpp"
35 #include "services/diagnosticCommand.hpp"
36 #include "services/diagnosticFramework.hpp"
37 #include "services/diagnosticCommand_ext.hpp"
38
39 class HelpDCmd : public DCmdWithParser {
40 protected:
41 DCmdArgument<bool> _all;
42 DCmdArgument<char*> _cmd;
43 public:
44 HelpDCmd(outputStream* output, bool heap);
45 static const char* name() { return "help"; }
46 static const char* description() {
47 return "For more information about a specific command use 'help <command>'. "
48 "With no argument this will show a list of available commands. "
49 "'help all' will show help for all commands.";
50 }
51 static const char* impact() { return "Low"; }
52 static int num_arguments();
53 virtual void execute(TRAPS);
54 };
55
56 class VersionDCmd : public DCmd {
57 public:
58 VersionDCmd(outputStream* output, bool heap) : DCmd(output,heap) { }
59 static const char* name() { return "VM.version"; }
60 static const char* description() {
61 return "Print JVM version information.";
62 }
63 static const char* impact() { return "Low"; }
64 static int num_arguments() { return 0; }
65 virtual void execute(TRAPS);
66 };
67
68 class CommandLineDCmd : public DCmd {
69 public:
70 CommandLineDCmd(outputStream* output, bool heap) : DCmd(output, heap) { }
71 static const char* name() { return "VM.command_line"; }
72 static const char* description() {
73 return "Print the command line used to start this VM instance.";
74 }
75 static const char* impact() { return "Low"; }
76 static int num_arguments() { return 0; }
77 virtual void execute(TRAPS) {
78 Arguments::print_on(_output);
79 }
80 };
81
82 // See also: get_system_properties in attachListener.cpp
83 class PrintSystemPropertiesDCmd : public DCmd {
84 public:
85 PrintSystemPropertiesDCmd(outputStream* output, bool heap) : DCmd(output, heap) { }
86 static const char* name() { return "VM.system_properties"; }
87 static const char* description() {
88 return "Print system properties.";
89 }
90 static const char* impact() {
91 return "Low";
92 }
93 static int num_arguments() { return 0; }
94 virtual void execute(TRAPS);
95 };
96
97 // See also: print_flag in attachListener.cpp
98 class PrintVMFlagsDCmd : public DCmdWithParser {
99 protected:
100 DCmdArgument<bool> _all;
101 public:
102 PrintVMFlagsDCmd(outputStream* output, bool heap);
103 static const char* name() { return "VM.flags"; }
104 static const char* description() {
105 return "Print VM flag options and their current values.";
106 }
107 static const char* impact() {
108 return "Low";
109 }
110 static int num_arguments();
111 virtual void execute(TRAPS);
112 };
113
114 class VMUptimeDCmd : public DCmdWithParser {
115 protected:
116 DCmdArgument<bool> _date;
117 public:
118 VMUptimeDCmd(outputStream* output, bool heap);
119 static const char* name() { return "VM.uptime"; }
120 static const char* description() {
121 return "Print VM uptime.";
122 }
123 static const char* impact() {
124 return "Low";
125 }
126 static int num_arguments();
127 virtual void execute(TRAPS);
128 };
129
130 class SystemGCDCmd : public DCmd {
131 public:
132 SystemGCDCmd(outputStream* output, bool heap) : DCmd(output, heap) { }
133 static const char* name() { return "GC.run"; }
134 static const char* description() {
135 return "Call java.lang.System.gc().";
136 }
137 static const char* impact() {
138 return "Medium: Depends on Java heap size and content.";
139 }
140 static int num_arguments() { return 0; }
141 virtual void execute(TRAPS);
142 };
143
144 class RunFinalizationDCmd : public DCmd {
145 public:
146 RunFinalizationDCmd(outputStream* output, bool heap) : DCmd(output, heap) { }
147 static const char* name() { return "GC.run_finalization"; }
148 static const char* description() {
149 return "Call java.lang.System.runFinalization().";
150 }
151 static const char* impact() {
152 return "Medium: Depends on Java content.";
153 }
154 static int num_arguments() { return 0; }
155 virtual void execute(TRAPS);
156 };
157
158 #if INCLUDE_SERVICES // Heap dumping supported
159 // See also: dump_heap in attachListener.cpp
160 class HeapDumpDCmd : public DCmdWithParser {
161 protected:
162 DCmdArgument<char*> _filename;
163 DCmdArgument<bool> _all;
164 public:
165 HeapDumpDCmd(outputStream* output, bool heap);
166 static const char* name() {
167 return "GC.heap_dump";
168 }
169 static const char* description() {
170 return "Generate a HPROF format dump of the Java heap.";
171 }
172 static const char* impact() {
173 return "High: Depends on Java heap size and content. "
174 "Request a full GC unless the '-all' option is specified.";
175 }
176 static int num_arguments();
177 virtual void execute(TRAPS);
178 };
179 #endif // INCLUDE_SERVICES
180
181 // See also: inspeactheap in attachListener.cpp
182 class ClassHistogramDCmd : public DCmdWithParser {
183 protected:
184 DCmdArgument<bool> _all;
185 public:
186 ClassHistogramDCmd(outputStream* output, bool heap);
187 static const char* name() {
188 return "GC.class_histogram";
189 }
190 static const char* description() {
191 return "Provide statistics about the Java heap usage.";
192 }
193 static const char* impact() {
194 return "High: Depends on Java heap size and content.";
195 }
196 static int num_arguments();
197 virtual void execute(TRAPS);
198 };
199
200 // See also: thread_dump in attachListener.cpp
201 class ThreadDumpDCmd : public DCmdWithParser {
202 protected:
203 DCmdArgument<bool> _locks;
204 public:
205 ThreadDumpDCmd(outputStream* output, bool heap);
206 static const char* name() { return "Thread.print"; }
207 static const char* description() {
208 return "Print all threads with stacktraces.";
209 }
210 static const char* impact() {
211 return "Medium: Depends on the number of threads.";
212 }
213 static int num_arguments();
214 virtual void execute(TRAPS);
215 };
216
217 // Enhanced JMX Agent support
218
219 class JMXStartRemoteDCmd : public DCmdWithParser {
220
221 // Explicitly list all properties that could be
222 // passed to Agent.startRemoteManagementAgent()
223 // com.sun.management is omitted
224
225 DCmdArgument<char *> _config_file;
226 DCmdArgument<char *> _jmxremote_port;
227 DCmdArgument<char *> _jmxremote_rmi_port;
228 DCmdArgument<char *> _jmxremote_ssl;
229 DCmdArgument<char *> _jmxremote_registry_ssl;
230 DCmdArgument<char *> _jmxremote_authenticate;
231 DCmdArgument<char *> _jmxremote_password_file;
232 DCmdArgument<char *> _jmxremote_access_file;
233 DCmdArgument<char *> _jmxremote_login_config;
234 DCmdArgument<char *> _jmxremote_ssl_enabled_cipher_suites;
235 DCmdArgument<char *> _jmxremote_ssl_enabled_protocols;
236 DCmdArgument<char *> _jmxremote_ssl_need_client_auth;
237 DCmdArgument<char *> _jmxremote_ssl_config_file;
238
239 public:
240 JMXStartRemoteDCmd(outputStream *output, bool heap_allocated);
241
242 static const char *name() {
243 return "ManagementAgent.start";
244 }
245
246 static const char *description() {
247 return "Start remote management agent.";
248 }
249
250 static int num_arguments();
251
252 virtual void execute(TRAPS);
253
254 };
255
256 class JMXStartLocalDCmd : public DCmd {
257
258 // Explicitly request start of local agent,
259 // it will not be started by start dcmd
260
261
262 public:
263 JMXStartLocalDCmd(outputStream *output, bool heap_allocated);
264
265 static const char *name() {
266 return "ManagementAgent.start_local";
267 }
268
269 static const char *description() {
270 return "Start local management agent.";
271 }
272
273 virtual void execute(TRAPS);
274
275 };
276
277 class JMXStopRemoteDCmd : public DCmd {
278 public:
279 JMXStopRemoteDCmd(outputStream *output, bool heap_allocated) :
280 DCmd(output, heap_allocated) {
281 // Do Nothing
282 }
283
284 static const char *name() {
285 return "ManagementAgent.stop";
286 }
287
288 static const char *description() {
289 return "Stop remote management agent.";
290 }
291
292 virtual void execute(TRAPS);
293 };
294
295 #endif // SHARE_VM_SERVICES_DIAGNOSTICCOMMAND_HPP
|
33 #include "runtime/os.hpp"
34 #include "services/diagnosticArgument.hpp"
35 #include "services/diagnosticCommand.hpp"
36 #include "services/diagnosticFramework.hpp"
37 #include "services/diagnosticCommand_ext.hpp"
38
39 class HelpDCmd : public DCmdWithParser {
40 protected:
41 DCmdArgument<bool> _all;
42 DCmdArgument<char*> _cmd;
43 public:
44 HelpDCmd(outputStream* output, bool heap);
45 static const char* name() { return "help"; }
46 static const char* description() {
47 return "For more information about a specific command use 'help <command>'. "
48 "With no argument this will show a list of available commands. "
49 "'help all' will show help for all commands.";
50 }
51 static const char* impact() { return "Low"; }
52 static int num_arguments();
53 virtual void execute(DCmdSource source, TRAPS);
54 };
55
56 class VersionDCmd : public DCmd {
57 public:
58 VersionDCmd(outputStream* output, bool heap) : DCmd(output,heap) { }
59 static const char* name() { return "VM.version"; }
60 static const char* description() {
61 return "Print JVM version information.";
62 }
63 static const char* impact() { return "Low"; }
64 static const JavaPermission permission() {
65 JavaPermission p = {"java.util.PropertyPermission",
66 "java.vm.version", "read"};
67 return p;
68 }
69 static int num_arguments() { return 0; }
70 virtual void execute(DCmdSource source, TRAPS);
71 };
72
73 class CommandLineDCmd : public DCmd {
74 public:
75 CommandLineDCmd(outputStream* output, bool heap) : DCmd(output, heap) { }
76 static const char* name() { return "VM.command_line"; }
77 static const char* description() {
78 return "Print the command line used to start this VM instance.";
79 }
80 static const char* impact() { return "Low"; }
81 static const JavaPermission permission() {
82 JavaPermission p = {"java.lang.management.ManagementPermission",
83 "monitor", NULL};
84 return p;
85 }
86 static int num_arguments() { return 0; }
87 virtual void execute(DCmdSource source, TRAPS) {
88 Arguments::print_on(_output);
89 }
90 };
91
92 // See also: get_system_properties in attachListener.cpp
93 class PrintSystemPropertiesDCmd : public DCmd {
94 public:
95 PrintSystemPropertiesDCmd(outputStream* output, bool heap) : DCmd(output, heap) { }
96 static const char* name() { return "VM.system_properties"; }
97 static const char* description() {
98 return "Print system properties.";
99 }
100 static const char* impact() {
101 return "Low";
102 }
103 static const JavaPermission permission() {
104 JavaPermission p = {"java.util.PropertyPermission",
105 "*", "read"};
106 return p;
107 }
108 static int num_arguments() { return 0; }
109 virtual void execute(DCmdSource source, TRAPS);
110 };
111
112 // See also: print_flag in attachListener.cpp
113 class PrintVMFlagsDCmd : public DCmdWithParser {
114 protected:
115 DCmdArgument<bool> _all;
116 public:
117 PrintVMFlagsDCmd(outputStream* output, bool heap);
118 static const char* name() { return "VM.flags"; }
119 static const char* description() {
120 return "Print VM flag options and their current values.";
121 }
122 static const char* impact() {
123 return "Low";
124 }
125 static const JavaPermission permission() {
126 JavaPermission p = {"java.lang.management.ManagementPermission",
127 "monitor", NULL};
128 return p;
129 }
130 static int num_arguments();
131 virtual void execute(DCmdSource source, TRAPS);
132 };
133
134 class VMUptimeDCmd : public DCmdWithParser {
135 protected:
136 DCmdArgument<bool> _date;
137 public:
138 VMUptimeDCmd(outputStream* output, bool heap);
139 static const char* name() { return "VM.uptime"; }
140 static const char* description() {
141 return "Print VM uptime.";
142 }
143 static const char* impact() {
144 return "Low";
145 }
146 static int num_arguments();
147 virtual void execute(DCmdSource source, TRAPS);
148 };
149
150 class SystemGCDCmd : public DCmd {
151 public:
152 SystemGCDCmd(outputStream* output, bool heap) : DCmd(output, heap) { }
153 static const char* name() { return "GC.run"; }
154 static const char* description() {
155 return "Call java.lang.System.gc().";
156 }
157 static const char* impact() {
158 return "Medium: Depends on Java heap size and content.";
159 }
160 static int num_arguments() { return 0; }
161 virtual void execute(DCmdSource source, TRAPS);
162 };
163
164 class RunFinalizationDCmd : public DCmd {
165 public:
166 RunFinalizationDCmd(outputStream* output, bool heap) : DCmd(output, heap) { }
167 static const char* name() { return "GC.run_finalization"; }
168 static const char* description() {
169 return "Call java.lang.System.runFinalization().";
170 }
171 static const char* impact() {
172 return "Medium: Depends on Java content.";
173 }
174 static int num_arguments() { return 0; }
175 virtual void execute(DCmdSource source, TRAPS);
176 };
177
178 #if INCLUDE_SERVICES // Heap dumping supported
179 // See also: dump_heap in attachListener.cpp
180 class HeapDumpDCmd : public DCmdWithParser {
181 protected:
182 DCmdArgument<char*> _filename;
183 DCmdArgument<bool> _all;
184 public:
185 HeapDumpDCmd(outputStream* output, bool heap);
186 static const char* name() {
187 return "GC.heap_dump";
188 }
189 static const char* description() {
190 return "Generate a HPROF format dump of the Java heap.";
191 }
192 static const char* impact() {
193 return "High: Depends on Java heap size and content. "
194 "Request a full GC unless the '-all' option is specified.";
195 }
196 static const JavaPermission permission() {
197 JavaPermission p = {"java.lang.management.ManagementPermission",
198 "monitor", NULL};
199 return p;
200 }
201 static int num_arguments();
202 virtual void execute(DCmdSource source, TRAPS);
203 };
204 #endif // INCLUDE_SERVICES
205
206 // See also: inspeactheap in attachListener.cpp
207 class ClassHistogramDCmd : public DCmdWithParser {
208 protected:
209 DCmdArgument<bool> _all;
210 public:
211 ClassHistogramDCmd(outputStream* output, bool heap);
212 static const char* name() {
213 return "GC.class_histogram";
214 }
215 static const char* description() {
216 return "Provide statistics about the Java heap usage.";
217 }
218 static const char* impact() {
219 return "High: Depends on Java heap size and content.";
220 }
221 static const JavaPermission permission() {
222 JavaPermission p = {"java.lang.management.ManagementPermission",
223 "monitor", NULL};
224 return p;
225 }
226 static int num_arguments();
227 virtual void execute(DCmdSource source, TRAPS);
228 };
229
230 // See also: thread_dump in attachListener.cpp
231 class ThreadDumpDCmd : public DCmdWithParser {
232 protected:
233 DCmdArgument<bool> _locks;
234 public:
235 ThreadDumpDCmd(outputStream* output, bool heap);
236 static const char* name() { return "Thread.print"; }
237 static const char* description() {
238 return "Print all threads with stacktraces.";
239 }
240 static const char* impact() {
241 return "Medium: Depends on the number of threads.";
242 }
243 static const JavaPermission permission() {
244 JavaPermission p = {"java.lang.management.ManagementPermission",
245 "monitor", NULL};
246 return p;
247 }
248 static int num_arguments();
249 virtual void execute(DCmdSource source, TRAPS);
250 };
251
252 // Enhanced JMX Agent support
253
254 class JMXStartRemoteDCmd : public DCmdWithParser {
255
256 // Explicitly list all properties that could be
257 // passed to Agent.startRemoteManagementAgent()
258 // com.sun.management is omitted
259
260 DCmdArgument<char *> _config_file;
261 DCmdArgument<char *> _jmxremote_port;
262 DCmdArgument<char *> _jmxremote_rmi_port;
263 DCmdArgument<char *> _jmxremote_ssl;
264 DCmdArgument<char *> _jmxremote_registry_ssl;
265 DCmdArgument<char *> _jmxremote_authenticate;
266 DCmdArgument<char *> _jmxremote_password_file;
267 DCmdArgument<char *> _jmxremote_access_file;
268 DCmdArgument<char *> _jmxremote_login_config;
269 DCmdArgument<char *> _jmxremote_ssl_enabled_cipher_suites;
270 DCmdArgument<char *> _jmxremote_ssl_enabled_protocols;
271 DCmdArgument<char *> _jmxremote_ssl_need_client_auth;
272 DCmdArgument<char *> _jmxremote_ssl_config_file;
273
274 public:
275 JMXStartRemoteDCmd(outputStream *output, bool heap_allocated);
276
277 static const char *name() {
278 return "ManagementAgent.start";
279 }
280
281 static const char *description() {
282 return "Start remote management agent.";
283 }
284
285 static int num_arguments();
286
287 virtual void execute(DCmdSource source, TRAPS);
288
289 };
290
291 class JMXStartLocalDCmd : public DCmd {
292
293 // Explicitly request start of local agent,
294 // it will not be started by start dcmd
295
296
297 public:
298 JMXStartLocalDCmd(outputStream *output, bool heap_allocated);
299
300 static const char *name() {
301 return "ManagementAgent.start_local";
302 }
303
304 static const char *description() {
305 return "Start local management agent.";
306 }
307
308 virtual void execute(DCmdSource source, TRAPS);
309
310 };
311
312 class JMXStopRemoteDCmd : public DCmd {
313 public:
314 JMXStopRemoteDCmd(outputStream *output, bool heap_allocated) :
315 DCmd(output, heap_allocated) {
316 // Do Nothing
317 }
318
319 static const char *name() {
320 return "ManagementAgent.stop";
321 }
322
323 static const char *description() {
324 return "Stop remote management agent.";
325 }
326
327 virtual void execute(DCmdSource source, TRAPS);
328 };
329
330 #endif // SHARE_VM_SERVICES_DIAGNOSTICCOMMAND_HPP
|