1 /*
2 * Copyright (c) 2011, 2015, 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 "classfile/vmSymbols.hpp"
29 #include "runtime/arguments.hpp"
30 #include "runtime/os.hpp"
31 #include "runtime/vmThread.hpp"
32 #include "services/diagnosticArgument.hpp"
33 #include "services/diagnosticCommand.hpp"
34 #include "services/diagnosticCommand_ext.hpp"
35 #include "services/diagnosticFramework.hpp"
36 #include "utilities/macros.hpp"
37 #include "utilities/ostream.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 VMDynamicLibrariesDCmd : public DCmd {
135 public:
136 VMDynamicLibrariesDCmd(outputStream* output, bool heap);
137 static const char* name() {
138 return "VM.dynlibs";
139 }
140 static const char* description() {
141 return "Print loaded dynamic libraries.";
142 }
143 static const char* impact() {
144 return "Low";
145 }
146 static const JavaPermission permission() {
147 JavaPermission p = {"java.lang.management.ManagementPermission",
148 "monitor", NULL};
149 return p;
150 }
151 static int num_arguments() {
152 return 0;
153 };
154 virtual void execute(DCmdSource source, TRAPS);
155 };
156
157 class VMUptimeDCmd : public DCmdWithParser {
158 protected:
159 DCmdArgument<bool> _date;
160 public:
161 VMUptimeDCmd(outputStream* output, bool heap);
162 static const char* name() { return "VM.uptime"; }
163 static const char* description() {
164 return "Print VM uptime.";
165 }
166 static const char* impact() {
167 return "Low";
168 }
169 static int num_arguments();
170 virtual void execute(DCmdSource source, TRAPS);
171 };
172
173 class SystemGCDCmd : public DCmd {
174 public:
175 SystemGCDCmd(outputStream* output, bool heap) : DCmd(output, heap) { }
176 static const char* name() { return "GC.run"; }
177 static const char* description() {
178 return "Call java.lang.System.gc().";
179 }
180 static const char* impact() {
181 return "Medium: Depends on Java heap size and content.";
182 }
183 static int num_arguments() { return 0; }
184 virtual void execute(DCmdSource source, TRAPS);
185 };
186
187 class RunFinalizationDCmd : public DCmd {
188 public:
189 RunFinalizationDCmd(outputStream* output, bool heap) : DCmd(output, heap) { }
190 static const char* name() { return "GC.run_finalization"; }
191 static const char* description() {
192 return "Call java.lang.System.runFinalization().";
193 }
194 static const char* impact() {
195 return "Medium: Depends on Java content.";
196 }
197 static int num_arguments() { return 0; }
198 virtual void execute(DCmdSource source, TRAPS);
199 };
200
201 #if INCLUDE_SERVICES // Heap dumping supported
202 // See also: dump_heap in attachListener.cpp
203 class HeapDumpDCmd : public DCmdWithParser {
204 protected:
205 DCmdArgument<char*> _filename;
206 DCmdArgument<bool> _all;
207 public:
208 HeapDumpDCmd(outputStream* output, bool heap);
209 static const char* name() {
210 return "GC.heap_dump";
211 }
212 static const char* description() {
213 return "Generate a HPROF format dump of the Java heap.";
214 }
215 static const char* impact() {
216 return "High: Depends on Java heap size and content. "
217 "Request a full GC unless the '-all' option is specified.";
218 }
219 static const JavaPermission permission() {
220 JavaPermission p = {"java.lang.management.ManagementPermission",
221 "monitor", NULL};
222 return p;
223 }
224 static int num_arguments();
225 virtual void execute(DCmdSource source, TRAPS);
226 };
227 #endif // INCLUDE_SERVICES
228
229 // See also: inspectheap in attachListener.cpp
230 class ClassHistogramDCmd : public DCmdWithParser {
231 protected:
232 DCmdArgument<bool> _all;
233 public:
234 ClassHistogramDCmd(outputStream* output, bool heap);
235 static const char* name() {
236 return "GC.class_histogram";
237 }
238 static const char* description() {
239 return "Provide statistics about the Java heap usage.";
240 }
241 static const char* impact() {
242 return "High: Depends on Java heap size and content.";
243 }
244 static const JavaPermission permission() {
245 JavaPermission p = {"java.lang.management.ManagementPermission",
246 "monitor", NULL};
247 return p;
248 }
249 static int num_arguments();
250 virtual void execute(DCmdSource source, TRAPS);
251 };
252
253 class ClassStatsDCmd : public DCmdWithParser {
254 protected:
255 DCmdArgument<bool> _all;
256 DCmdArgument<bool> _csv;
257 DCmdArgument<bool> _help;
258 DCmdArgument<char*> _columns;
259 public:
260 ClassStatsDCmd(outputStream* output, bool heap);
261 static const char* name() {
262 return "GC.class_stats";
263 }
264 static const char* description() {
265 return "Provide statistics about Java class meta data. Requires -XX:+UnlockDiagnosticVMOptions.";
266 }
267 static const char* impact() {
268 return "High: Depends on Java heap size and content.";
269 }
270 static int num_arguments();
271 virtual void execute(DCmdSource source, TRAPS);
272 };
273
274
275 class ClassHierarchyDCmd : public DCmdWithParser {
276 protected:
277 DCmdArgument<bool> _print_interfaces; // true if inherited interfaces should be printed.
278 DCmdArgument<bool> _print_subclasses; // true if subclasses of the specified classname should be printed.
279 DCmdArgument<char*> _classname; // Optional single class name whose hierarchy should be printed.
280 public:
281 ClassHierarchyDCmd(outputStream* output, bool heap);
282 static const char* name() {
283 return "VM.class_hierarchy";
284 }
285 static const char* description() {
286 return "Print a list of all loaded classes, indented to show the class hiearchy. "
287 "The name of each class is followed by the ClassLoaderData* of its ClassLoader, "
288 "or \"null\" if loaded by the bootstrap class loader.";
289 }
290 static const char* impact() {
291 return "Medium: Depends on number of loaded classes.";
292 }
293 static const JavaPermission permission() {
294 JavaPermission p = {"java.lang.management.ManagementPermission",
295 "monitor", NULL};
296 return p;
297 }
298 static int num_arguments();
299 virtual void execute(DCmdSource source, TRAPS);
300 };
301
302 class MethodUsageDCmd : public DCmdWithParser {
303 public:
304 MethodUsageDCmd(outputStream* output, bool heap);
305 static const char* name() {
306 return "VM.method_usage";
307 }
308 static const char* description() {
309 return "Dump all methods that have been used during the lifetime of this JVM.";
310 }
311 static const char* impact() {
312 return "Medium: Depends on Java content.";
313 }
314 static int num_arguments();
315 virtual void execute(DCmdSource source, TRAPS);
316 };
317
318 // See also: thread_dump in attachListener.cpp
319 class ThreadDumpDCmd : public DCmdWithParser {
320 protected:
321 DCmdArgument<bool> _locks;
322 public:
323 ThreadDumpDCmd(outputStream* output, bool heap);
324 static const char* name() { return "Thread.print"; }
325 static const char* description() {
326 return "Print all threads with stacktraces.";
327 }
328 static const char* impact() {
329 return "Medium: Depends on the number of threads.";
330 }
331 static const JavaPermission permission() {
332 JavaPermission p = {"java.lang.management.ManagementPermission",
333 "monitor", NULL};
334 return p;
335 }
336 static int num_arguments();
337 virtual void execute(DCmdSource source, TRAPS);
338 };
339
340 // Enhanced JMX Agent support
341
342 class JMXStartRemoteDCmd : public DCmdWithParser {
343
344 // Explicitly list all properties that could be
345 // passed to Agent.startRemoteManagementAgent()
346 // com.sun.management is omitted
347
348 DCmdArgument<char *> _config_file;
349 DCmdArgument<char *> _jmxremote_port;
350 DCmdArgument<char *> _jmxremote_rmi_port;
351 DCmdArgument<char *> _jmxremote_ssl;
352 DCmdArgument<char *> _jmxremote_registry_ssl;
353 DCmdArgument<char *> _jmxremote_authenticate;
354 DCmdArgument<char *> _jmxremote_password_file;
355 DCmdArgument<char *> _jmxremote_access_file;
356 DCmdArgument<char *> _jmxremote_login_config;
357 DCmdArgument<char *> _jmxremote_ssl_enabled_cipher_suites;
358 DCmdArgument<char *> _jmxremote_ssl_enabled_protocols;
359 DCmdArgument<char *> _jmxremote_ssl_need_client_auth;
360 DCmdArgument<char *> _jmxremote_ssl_config_file;
361
362 // JDP support
363 // Keep autodiscovery char* not bool to pass true/false
364 // as property value to java level.
365 DCmdArgument<char *> _jmxremote_autodiscovery;
366 DCmdArgument<jlong> _jdp_port;
367 DCmdArgument<char *> _jdp_address;
368 DCmdArgument<char *> _jdp_source_addr;
369 DCmdArgument<jlong> _jdp_ttl;
370 DCmdArgument<jlong> _jdp_pause;
371 DCmdArgument<char *> _jdp_name;
372
373 public:
374 JMXStartRemoteDCmd(outputStream *output, bool heap_allocated);
375
376 static const char *name() {
377 return "ManagementAgent.start";
378 }
379
380 static const char *description() {
381 return "Start remote management agent.";
382 }
383
384 static int num_arguments();
385
386 virtual void execute(DCmdSource source, TRAPS);
387
388 };
389
390 class JMXStartLocalDCmd : public DCmd {
391
392 // Explicitly request start of local agent,
393 // it will not be started by start dcmd
394
395
396 public:
397 JMXStartLocalDCmd(outputStream *output, bool heap_allocated);
398
399 static const char *name() {
400 return "ManagementAgent.start_local";
401 }
402
403 static const char *description() {
404 return "Start local management agent.";
405 }
406
407 virtual void execute(DCmdSource source, TRAPS);
408
409 };
410
411 class JMXStopRemoteDCmd : public DCmd {
412 public:
413 JMXStopRemoteDCmd(outputStream *output, bool heap_allocated) :
414 DCmd(output, heap_allocated) {
415 // Do Nothing
416 }
417
418 static const char *name() {
419 return "ManagementAgent.stop";
420 }
421
422 static const char *description() {
423 return "Stop remote management agent.";
424 }
425
426 virtual void execute(DCmdSource source, TRAPS);
427 };
428
429 class RotateGCLogDCmd : public DCmd {
430 public:
431 RotateGCLogDCmd(outputStream* output, bool heap) : DCmd(output, heap) {}
432 static const char* name() { return "GC.rotate_log"; }
433 static const char* description() {
434 return "Force the GC log file to be rotated.";
435 }
436 static const char* impact() { return "Low"; }
437 virtual void execute(DCmdSource source, TRAPS);
438 static int num_arguments() { return 0; }
439 static const JavaPermission permission() {
440 JavaPermission p = {"java.lang.management.ManagementPermission",
441 "control", NULL};
442 return p;
443 }
444 };
445
446 class CompileQueueDCmd : public DCmd {
447 public:
448 CompileQueueDCmd(outputStream* output, bool heap) : DCmd(output, heap) {}
449 static const char* name() {
450 return "Compiler.queue";
451 }
452 static const char* description() {
453 return "Print methods queued for compilation.";
454 }
455 static const char* impact() {
456 return "Low";
457 }
458 static const JavaPermission permission() {
459 JavaPermission p = {"java.lang.management.ManagementPermission",
460 "monitor", NULL};
461 return p;
462 }
463 static int num_arguments() { return 0; }
464 virtual void execute(DCmdSource source, TRAPS);
465 };
466
467 class CodeListDCmd : public DCmd {
468 public:
469 CodeListDCmd(outputStream* output, bool heap) : DCmd(output, heap) {}
470 static const char* name() {
471 return "Compiler.codelist";
472 }
473 static const char* description() {
474 return "Print all compiled methods in code cache that are alive";
475 }
476 static const char* impact() {
477 return "Medium";
478 }
479 static const JavaPermission permission() {
480 JavaPermission p = {"java.lang.management.ManagementPermission",
481 "monitor", NULL};
482 return p;
483 }
484 static int num_arguments() { return 0; }
485 virtual void execute(DCmdSource source, TRAPS);
486 };
487
488
489 class CodeCacheDCmd : public DCmd {
490 public:
491 CodeCacheDCmd(outputStream* output, bool heap) : DCmd(output, heap) {}
492 static const char* name() {
493 return "Compiler.codecache";
494 }
495 static const char* description() {
496 return "Print code cache layout and bounds.";
497 }
498 static const char* impact() {
499 return "Low";
500 }
501 static const JavaPermission permission() {
502 JavaPermission p = {"java.lang.management.ManagementPermission",
503 "monitor", NULL};
504 return p;
505 }
506 static int num_arguments() { return 0; }
507 virtual void execute(DCmdSource source, TRAPS);
508 };
509
510 #endif // SHARE_VM_SERVICES_DIAGNOSTICCOMMAND_HPP