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 DCmd {
276 public:
277 ClassHierarchyDCmd(outputStream* output, bool heap) : DCmd(output, heap) { }
278 static const char* name() {
279 return "VM.class_hierarchy";
280 }
281 static const char* description() {
282 return "Print a list of all loaded classes, indented to show the class hiearchy.";
283 }
284 static const char* impact() {
285 return "Medium: Depends on number of loaded classes.";
286 }
287 virtual void execute(DCmdSource source, TRAPS);
288 };
289
290 // See also: thread_dump in attachListener.cpp
291 class ThreadDumpDCmd : public DCmdWithParser {
292 protected:
293 DCmdArgument<bool> _locks;
294 public:
295 ThreadDumpDCmd(outputStream* output, bool heap);
296 static const char* name() { return "Thread.print"; }
297 static const char* description() {
298 return "Print all threads with stacktraces.";
299 }
300 static const char* impact() {
301 return "Medium: Depends on the number of threads.";
302 }
303 static const JavaPermission permission() {
304 JavaPermission p = {"java.lang.management.ManagementPermission",
305 "monitor", NULL};
306 return p;
307 }
308 static int num_arguments();
309 virtual void execute(DCmdSource source, TRAPS);
310 };
311
312 // Enhanced JMX Agent support
313
314 class JMXStartRemoteDCmd : public DCmdWithParser {
315
316 // Explicitly list all properties that could be
317 // passed to Agent.startRemoteManagementAgent()
318 // com.sun.management is omitted
319
320 DCmdArgument<char *> _config_file;
321 DCmdArgument<char *> _jmxremote_port;
322 DCmdArgument<char *> _jmxremote_rmi_port;
323 DCmdArgument<char *> _jmxremote_ssl;
324 DCmdArgument<char *> _jmxremote_registry_ssl;
325 DCmdArgument<char *> _jmxremote_authenticate;
326 DCmdArgument<char *> _jmxremote_password_file;
327 DCmdArgument<char *> _jmxremote_access_file;
328 DCmdArgument<char *> _jmxremote_login_config;
329 DCmdArgument<char *> _jmxremote_ssl_enabled_cipher_suites;
330 DCmdArgument<char *> _jmxremote_ssl_enabled_protocols;
331 DCmdArgument<char *> _jmxremote_ssl_need_client_auth;
332 DCmdArgument<char *> _jmxremote_ssl_config_file;
333
334 // JDP support
335 // Keep autodiscovery char* not bool to pass true/false
336 // as property value to java level.
337 DCmdArgument<char *> _jmxremote_autodiscovery;
338 DCmdArgument<jlong> _jdp_port;
339 DCmdArgument<char *> _jdp_address;
340 DCmdArgument<char *> _jdp_source_addr;
341 DCmdArgument<jlong> _jdp_ttl;
342 DCmdArgument<jlong> _jdp_pause;
343 DCmdArgument<char *> _jdp_name;
344
345 public:
346 JMXStartRemoteDCmd(outputStream *output, bool heap_allocated);
347
348 static const char *name() {
349 return "ManagementAgent.start";
350 }
351
352 static const char *description() {
353 return "Start remote management agent.";
354 }
355
356 static int num_arguments();
357
358 virtual void execute(DCmdSource source, TRAPS);
359
360 };
361
362 class JMXStartLocalDCmd : public DCmd {
363
364 // Explicitly request start of local agent,
365 // it will not be started by start dcmd
366
367
368 public:
369 JMXStartLocalDCmd(outputStream *output, bool heap_allocated);
370
371 static const char *name() {
372 return "ManagementAgent.start_local";
373 }
374
375 static const char *description() {
376 return "Start local management agent.";
377 }
378
379 virtual void execute(DCmdSource source, TRAPS);
380
381 };
382
383 class JMXStopRemoteDCmd : public DCmd {
384 public:
385 JMXStopRemoteDCmd(outputStream *output, bool heap_allocated) :
386 DCmd(output, heap_allocated) {
387 // Do Nothing
388 }
389
390 static const char *name() {
391 return "ManagementAgent.stop";
392 }
393
394 static const char *description() {
395 return "Stop remote management agent.";
396 }
397
398 virtual void execute(DCmdSource source, TRAPS);
399 };
400
401 class RotateGCLogDCmd : public DCmd {
402 public:
403 RotateGCLogDCmd(outputStream* output, bool heap) : DCmd(output, heap) {}
404 static const char* name() { return "GC.rotate_log"; }
405 static const char* description() {
406 return "Force the GC log file to be rotated.";
407 }
408 static const char* impact() { return "Low"; }
409 virtual void execute(DCmdSource source, TRAPS);
410 static int num_arguments() { return 0; }
411 static const JavaPermission permission() {
412 JavaPermission p = {"java.lang.management.ManagementPermission",
413 "control", NULL};
414 return p;
415 }
416 };
417
418 class CompileQueueDCmd : public DCmd {
419 public:
420 CompileQueueDCmd(outputStream* output, bool heap) : DCmd(output, heap) {}
421 static const char* name() {
422 return "Compiler.queue";
423 }
424 static const char* description() {
425 return "Print methods queued for compilation.";
426 }
427 static const char* impact() {
428 return "Low";
429 }
430 static const JavaPermission permission() {
431 JavaPermission p = {"java.lang.management.ManagementPermission",
432 "monitor", NULL};
433 return p;
434 }
435 static int num_arguments() { return 0; }
436 virtual void execute(DCmdSource source, TRAPS);
437 };
438
439 class CodeListDCmd : public DCmd {
440 public:
441 CodeListDCmd(outputStream* output, bool heap) : DCmd(output, heap) {}
442 static const char* name() {
443 return "Compiler.codelist";
444 }
445 static const char* description() {
446 return "Print all compiled methods in code cache that are alive";
447 }
448 static const char* impact() {
449 return "Medium";
450 }
451 static const JavaPermission permission() {
452 JavaPermission p = {"java.lang.management.ManagementPermission",
453 "monitor", NULL};
454 return p;
455 }
456 static int num_arguments() { return 0; }
457 virtual void execute(DCmdSource source, TRAPS);
458 };
459
460
461 class CodeCacheDCmd : public DCmd {
462 public:
463 CodeCacheDCmd(outputStream* output, bool heap) : DCmd(output, heap) {}
464 static const char* name() {
465 return "Compiler.codecache";
466 }
467 static const char* description() {
468 return "Print code cache layout and bounds.";
469 }
470 static const char* impact() {
471 return "Low";
472 }
473 static const JavaPermission permission() {
474 JavaPermission p = {"java.lang.management.ManagementPermission",
475 "monitor", NULL};
476 return p;
477 }
478 static int num_arguments() { return 0; }
479 virtual void execute(DCmdSource source, TRAPS);
480 };
481
482 #endif // SHARE_VM_SERVICES_DIAGNOSTICCOMMAND_HPP