1 /*
2 * Copyright (c) 2011, 2013, 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_VM_SERVICES_DIAGNOSTICCOMMAND_HPP
26 #define SHARE_VM_SERVICES_DIAGNOSTICCOMMAND_HPP
27
28 #include "runtime/arguments.hpp"
29 #include "classfile/vmSymbols.hpp"
30 #include "utilities/ostream.hpp"
31 #include "runtime/vm_version.hpp"
32 #include "runtime/vmThread.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 #include "utilities/macros.hpp"
39
40 class HelpDCmd : public DCmdWithParser {
41 protected:
42 DCmdArgument<bool> _all;
43 DCmdArgument<char*> _cmd;
44 public:
45 HelpDCmd(outputStream* output, bool heap);
46 static const char* name() { return "help"; }
47 static const char* description() {
48 return "For more information about a specific command use 'help <command>'. "
49 "With no argument this will show a list of available commands. "
50 "'help all' will show help for all commands.";
51 }
52 static const char* impact() { return "Low"; }
53 static int num_arguments();
54 virtual void execute(DCmdSource source, TRAPS);
55 };
56
57 class VersionDCmd : public DCmd {
58 public:
59 VersionDCmd(outputStream* output, bool heap) : DCmd(output,heap) { }
60 static const char* name() { return "VM.version"; }
61 static const char* description() {
62 return "Print JVM version information.";
63 }
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 }
70 static int num_arguments() { return 0; }
71 virtual void execute(DCmdSource source, TRAPS);
72 };
73
74 class CommandLineDCmd : public DCmd {
75 public:
76 CommandLineDCmd(outputStream* output, bool heap) : DCmd(output, heap) { }
77 static const char* name() { return "VM.command_line"; }
78 static const char* description() {
79 return "Print the command line used to start this VM instance.";
80 }
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 }
87 static int num_arguments() { return 0; }
88 virtual void execute(DCmdSource source, TRAPS) {
89 Arguments::print_on(_output);
90 }
91 };
92
93 // See also: get_system_properties in attachListener.cpp
94 class PrintSystemPropertiesDCmd : public DCmd {
95 public:
96 PrintSystemPropertiesDCmd(outputStream* output, bool heap) : DCmd(output, heap) { }
97 static const char* name() { return "VM.system_properties"; }
98 static const char* description() {
99 return "Print system properties.";
100 }
101 static const char* impact() {
102 return "Low";
103 }
104 static const JavaPermission permission() {
105 JavaPermission p = {"java.util.PropertyPermission",
106 "*", "read"};
107 return p;
108 }
109 static int num_arguments() { return 0; }
110 virtual void execute(DCmdSource source, TRAPS);
111 };
112
113 // See also: print_flag in attachListener.cpp
114 class PrintVMFlagsDCmd : public DCmdWithParser {
115 protected:
116 DCmdArgument<bool> _all;
117 public:
118 PrintVMFlagsDCmd(outputStream* output, bool heap);
119 static const char* name() { return "VM.flags"; }
120 static const char* description() {
121 return "Print VM flag options and their current values.";
122 }
123 static const char* impact() {
124 return "Low";
125 }
126 static const JavaPermission permission() {
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);
133 };
134
135 class VMDynamicLibrariesDCmd : public DCmd {
136 public:
137 VMDynamicLibrariesDCmd(outputStream* output, bool heap);
138 static const char* name() {
139 return "VM.dynlibs";
140 }
141 static const char* description() {
142 return "Print loaded dynamic libraries.";
143 }
144 static const char* impact() {
145 return "Low";
146 }
147 static const JavaPermission permission() {
148 JavaPermission p = {"java.lang.management.ManagementPermission",
149 "monitor", NULL};
150 return p;
151 }
152 static int num_arguments() {
153 return 0;
154 };
155 virtual void execute(DCmdSource source, TRAPS);
156 };
157
158 class VMUptimeDCmd : public DCmdWithParser {
159 protected:
160 DCmdArgument<bool> _date;
161 public:
162 VMUptimeDCmd(outputStream* output, bool heap);
163 static const char* name() { return "VM.uptime"; }
164 static const char* description() {
165 return "Print VM uptime.";
166 }
167 static const char* impact() {
168 return "Low";
169 }
170 static int num_arguments();
171 virtual void execute(DCmdSource source, TRAPS);
172 };
173
174 class SystemGCDCmd : public DCmd {
175 public:
176 SystemGCDCmd(outputStream* output, bool heap) : DCmd(output, heap) { }
177 static const char* name() { return "GC.run"; }
178 static const char* description() {
179 return "Call java.lang.System.gc().";
180 }
181 static const char* impact() {
182 return "Medium: Depends on Java heap size and content.";
183 }
184 static int num_arguments() { return 0; }
185 virtual void execute(DCmdSource source, TRAPS);
186 };
187
188 class RunFinalizationDCmd : public DCmd {
189 public:
190 RunFinalizationDCmd(outputStream* output, bool heap) : DCmd(output, heap) { }
191 static const char* name() { return "GC.run_finalization"; }
192 static const char* description() {
193 return "Call java.lang.System.runFinalization().";
194 }
195 static const char* impact() {
196 return "Medium: Depends on Java content.";
197 }
198 static int num_arguments() { return 0; }
199 virtual void execute(DCmdSource source, TRAPS);
200 };
201
202 #if INCLUDE_SERVICES // Heap dumping supported
203 // See also: dump_heap in attachListener.cpp
204 class HeapDumpDCmd : public DCmdWithParser {
205 protected:
206 DCmdArgument<char*> _filename;
207 DCmdArgument<bool> _all;
208 public:
209 HeapDumpDCmd(outputStream* output, bool heap);
210 static const char* name() {
211 return "GC.heap_dump";
212 }
213 static const char* description() {
214 return "Generate a HPROF format dump of the Java heap.";
215 }
216 static const char* impact() {
217 return "High: Depends on Java heap size and content. "
218 "Request a full GC unless the '-all' option is specified.";
219 }
220 static const JavaPermission permission() {
221 JavaPermission p = {"java.lang.management.ManagementPermission",
222 "monitor", NULL};
223 return p;
224 }
225 static int num_arguments();
226 virtual void execute(DCmdSource source, TRAPS);
227 };
228 #endif // INCLUDE_SERVICES
229
230 // See also: inspectheap in attachListener.cpp
231 class ClassHistogramDCmd : public DCmdWithParser {
232 protected:
233 DCmdArgument<bool> _all;
234 public:
235 ClassHistogramDCmd(outputStream* output, bool heap);
236 static const char* name() {
237 return "GC.class_histogram";
238 }
239 static const char* description() {
240 return "Provide statistics about the Java heap usage.";
241 }
242 static const char* impact() {
243 return "High: Depends on Java heap size and content.";
244 }
245 static const JavaPermission permission() {
246 JavaPermission p = {"java.lang.management.ManagementPermission",
247 "monitor", NULL};
248 return p;
249 }
250 static int num_arguments();
251 virtual void execute(DCmdSource source, TRAPS);
252 };
253
254 class ClassStatsDCmd : public DCmdWithParser {
255 protected:
256 DCmdArgument<bool> _all;
257 DCmdArgument<bool> _csv;
258 DCmdArgument<bool> _help;
259 DCmdArgument<char*> _columns;
260 public:
261 ClassStatsDCmd(outputStream* output, bool heap);
262 static const char* name() {
263 return "GC.class_stats";
264 }
265 static const char* description() {
266 return "Provide statistics about Java class meta data. Requires -XX:+UnlockDiagnosticVMOptions.";
267 }
268 static const char* impact() {
269 return "High: Depends on Java heap size and content.";
270 }
271 static int num_arguments();
272 virtual void execute(DCmdSource source, TRAPS);
273 };
274
275 // See also: thread_dump in attachListener.cpp
276 class ThreadDumpDCmd : public DCmdWithParser {
277 protected:
278 DCmdArgument<bool> _locks;
279 public:
280 ThreadDumpDCmd(outputStream* output, bool heap);
281 static const char* name() { return "Thread.print"; }
282 static const char* description() {
283 return "Print all threads with stacktraces.";
284 }
285 static const char* impact() {
286 return "Medium: Depends on the number of threads.";
287 }
288 static const JavaPermission permission() {
289 JavaPermission p = {"java.lang.management.ManagementPermission",
290 "monitor", NULL};
291 return p;
292 }
293 static int num_arguments();
294 virtual void execute(DCmdSource source, TRAPS);
295 };
296
297 // Enhanced JMX Agent support
298
299 class JMXStartRemoteDCmd : public DCmdWithParser {
300
301 // Explicitly list all properties that could be
302 // passed to Agent.startRemoteManagementAgent()
303 // com.sun.management is omitted
304
305 DCmdArgument<char *> _config_file;
306 DCmdArgument<char *> _jmxremote_port;
307 DCmdArgument<char *> _jmxremote_rmi_port;
308 DCmdArgument<char *> _jmxremote_ssl;
309 DCmdArgument<char *> _jmxremote_registry_ssl;
310 DCmdArgument<char *> _jmxremote_authenticate;
311 DCmdArgument<char *> _jmxremote_password_file;
312 DCmdArgument<char *> _jmxremote_access_file;
313 DCmdArgument<char *> _jmxremote_login_config;
314 DCmdArgument<char *> _jmxremote_ssl_enabled_cipher_suites;
315 DCmdArgument<char *> _jmxremote_ssl_enabled_protocols;
316 DCmdArgument<char *> _jmxremote_ssl_need_client_auth;
317 DCmdArgument<char *> _jmxremote_ssl_config_file;
318
319 // JDP support
320 // Keep autodiscovery char* not bool to pass true/false
321 // as property value to java level.
322 DCmdArgument<char *> _jmxremote_autodiscovery;
323 DCmdArgument<jlong> _jdp_port;
324 DCmdArgument<char *> _jdp_address;
325 DCmdArgument<char *> _jdp_source_addr;
326 DCmdArgument<jlong> _jdp_ttl;
327 DCmdArgument<jlong> _jdp_pause;
328 DCmdArgument<char *> _jdp_name;
329
330 public:
331 JMXStartRemoteDCmd(outputStream *output, bool heap_allocated);
332
333 static const char *name() {
334 return "ManagementAgent.start";
335 }
336
337 static const char *description() {
338 return "Start remote management agent.";
339 }
340
341 static int num_arguments();
342
343 virtual void execute(DCmdSource source, TRAPS);
344
345 };
346
347 class JMXStartLocalDCmd : public DCmd {
348
349 // Explicitly request start of local agent,
350 // it will not be started by start dcmd
351
352
353 public:
354 JMXStartLocalDCmd(outputStream *output, bool heap_allocated);
355
356 static const char *name() {
357 return "ManagementAgent.start_local";
358 }
359
360 static const char *description() {
361 return "Start local management agent.";
362 }
363
364 virtual void execute(DCmdSource source, TRAPS);
365
366 };
367
368 class JMXStopRemoteDCmd : public DCmd {
369 public:
370 JMXStopRemoteDCmd(outputStream *output, bool heap_allocated) :
371 DCmd(output, heap_allocated) {
372 // Do Nothing
373 }
374
375 static const char *name() {
376 return "ManagementAgent.stop";
377 }
378
379 static const char *description() {
380 return "Stop remote management agent.";
381 }
382
383 virtual void execute(DCmdSource source, TRAPS);
384 };
385
386 class RotateGCLogDCmd : public DCmd {
387 public:
388 RotateGCLogDCmd(outputStream* output, bool heap) : DCmd(output, heap) {}
389 static const char* name() { return "GC.rotate_log"; }
390 static const char* description() {
391 return "Force the GC log file to be rotated.";
392 }
393 static const char* impact() { return "Low"; }
394 virtual void execute(DCmdSource source, TRAPS);
395 static int num_arguments() { return 0; }
396 static const JavaPermission permission() {
397 JavaPermission p = {"java.lang.management.ManagementPermission",
398 "control", NULL};
399 return p;
400 }
401 };
402
403 #endif // SHARE_VM_SERVICES_DIAGNOSTICCOMMAND_HPP