1 /*
2 * Copyright (c) 2011, 2018, 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/stringTable.hpp"
29 #include "classfile/symbolTable.hpp"
30 #include "classfile/systemDictionary.hpp"
31 #include "classfile/vmSymbols.hpp"
32 #include "runtime/arguments.hpp"
33 #include "runtime/os.hpp"
34 #include "runtime/vmThread.hpp"
35 #include "services/diagnosticArgument.hpp"
36 #include "services/diagnosticCommand.hpp"
37 #include "services/diagnosticCommand_ext.hpp"
38 #include "services/diagnosticFramework.hpp"
39 #include "utilities/macros.hpp"
40 #include "utilities/ostream.hpp"
41 #include "oops/method.hpp"
42
43 class HelpDCmd : public DCmdWithParser {
44 protected:
45 DCmdArgument<bool> _all;
46 DCmdArgument<char*> _cmd;
47 public:
48 HelpDCmd(outputStream* output, bool heap);
49 static const char* name() { return "help"; }
50 static const char* description() {
51 return "For more information about a specific command use 'help <command>'. "
52 "With no argument this will show a list of available commands. "
53 "'help all' will show help for all commands.";
54 }
55 static const char* impact() { return "Low"; }
56 static int num_arguments();
57 virtual void execute(DCmdSource source, TRAPS);
58 };
59
60 class VersionDCmd : public DCmd {
61 public:
62 VersionDCmd(outputStream* output, bool heap) : DCmd(output,heap) { }
63 static const char* name() { return "VM.version"; }
64 static const char* description() {
65 return "Print JVM version information.";
66 }
67 static const char* impact() { return "Low"; }
68 static const JavaPermission permission() {
69 JavaPermission p = {"java.util.PropertyPermission",
70 "java.vm.version", "read"};
71 return p;
72 }
73 static int num_arguments() { return 0; }
74 virtual void execute(DCmdSource source, TRAPS);
75 };
76
77 class CommandLineDCmd : public DCmd {
78 public:
79 CommandLineDCmd(outputStream* output, bool heap) : DCmd(output, heap) { }
80 static const char* name() { return "VM.command_line"; }
81 static const char* description() {
82 return "Print the command line used to start this VM instance.";
83 }
84 static const char* impact() { return "Low"; }
85 static const JavaPermission permission() {
86 JavaPermission p = {"java.lang.management.ManagementPermission",
87 "monitor", NULL};
88 return p;
89 }
90 static int num_arguments() { return 0; }
91 virtual void execute(DCmdSource source, TRAPS) {
92 Arguments::print_on(_output);
93 }
94 };
95
96 // See also: get_system_properties in attachListener.cpp
97 class PrintSystemPropertiesDCmd : public DCmd {
98 public:
99 PrintSystemPropertiesDCmd(outputStream* output, bool heap) : DCmd(output, heap) { }
100 static const char* name() { return "VM.system_properties"; }
101 static const char* description() {
102 return "Print system properties.";
103 }
104 static const char* impact() {
105 return "Low";
106 }
107 static const JavaPermission permission() {
108 JavaPermission p = {"java.util.PropertyPermission",
109 "*", "read"};
110 return p;
111 }
112 static int num_arguments() { return 0; }
113 virtual void execute(DCmdSource source, TRAPS);
114 };
115
116 // See also: print_flag in attachListener.cpp
117 class PrintVMFlagsDCmd : public DCmdWithParser {
118 protected:
119 DCmdArgument<bool> _all;
120 public:
121 PrintVMFlagsDCmd(outputStream* output, bool heap);
122 static const char* name() { return "VM.flags"; }
123 static const char* description() {
124 return "Print VM flag options and their current values.";
125 }
126 static const char* impact() {
127 return "Low";
128 }
129 static const JavaPermission permission() {
130 JavaPermission p = {"java.lang.management.ManagementPermission",
131 "monitor", NULL};
132 return p;
133 }
134 static int num_arguments();
135 virtual void execute(DCmdSource source, TRAPS);
136 };
137
138 class SetVMFlagDCmd : public DCmdWithParser {
139 protected:
140 DCmdArgument<char*> _flag;
141 DCmdArgument<char*> _value;
142
143 public:
144 SetVMFlagDCmd(outputStream* output, bool heap);
145 static const char* name() { return "VM.set_flag"; }
146 static const char* description() {
147 return "Sets VM flag option using the provided value.";
148 }
149 static const char* impact() {
150 return "Low";
151 }
152 static const JavaPermission permission() {
153 JavaPermission p = {"java.lang.management.ManagementPermission",
154 "control", NULL};
155 return p;
156 }
157 static int num_arguments();
158 virtual void execute(DCmdSource source, TRAPS);
159 };
160
161 class JVMTIDataDumpDCmd : public DCmd {
162 public:
163 JVMTIDataDumpDCmd(outputStream* output, bool heap) : DCmd(output, heap) { }
164 static const char* name() { return "JVMTI.data_dump"; }
165 static const char* description() {
166 return "Signal the JVM to do a data-dump request for JVMTI.";
167 }
168 static const char* impact() {
169 return "High";
170 }
171 static const JavaPermission permission() {
172 JavaPermission p = {"java.lang.management.ManagementPermission",
173 "monitor", NULL};
174 return p;
175 }
176 static int num_arguments() { return 0; }
177 virtual void execute(DCmdSource source, TRAPS);
178 };
179
180 #if INCLUDE_SERVICES
181 #if INCLUDE_JVMTI
182 class JVMTIAgentLoadDCmd : public DCmdWithParser {
183 protected:
184 DCmdArgument<char*> _libpath;
185 DCmdArgument<char*> _option;
186 public:
187 JVMTIAgentLoadDCmd(outputStream* output, bool heap);
188 static const char* name() { return "JVMTI.agent_load"; }
189 static const char* description() {
190 return "Load JVMTI native agent.";
191 }
192 static const char* impact() { return "Low"; }
193 static const JavaPermission permission() {
194 JavaPermission p = {"java.lang.management.ManagementPermission",
195 "control", NULL};
196 return p;
197 }
198 static int num_arguments();
199 virtual void execute(DCmdSource source, TRAPS);
200 };
201 #endif // INCLUDE_JVMTI
202 #endif // INCLUDE_SERVICES
203
204 class VMDynamicLibrariesDCmd : public DCmd {
205 public:
206 VMDynamicLibrariesDCmd(outputStream* output, bool heap);
207 static const char* name() {
208 return "VM.dynlibs";
209 }
210 static const char* description() {
211 return "Print loaded dynamic libraries.";
212 }
213 static const char* impact() {
214 return "Low";
215 }
216 static const JavaPermission permission() {
217 JavaPermission p = {"java.lang.management.ManagementPermission",
218 "monitor", NULL};
219 return p;
220 }
221 static int num_arguments() {
222 return 0;
223 };
224 virtual void execute(DCmdSource source, TRAPS);
225 };
226
227 class VMUptimeDCmd : public DCmdWithParser {
228 protected:
229 DCmdArgument<bool> _date;
230 public:
231 VMUptimeDCmd(outputStream* output, bool heap);
232 static const char* name() { return "VM.uptime"; }
233 static const char* description() {
234 return "Print VM uptime.";
235 }
236 static const char* impact() {
237 return "Low";
238 }
239 static int num_arguments();
240 virtual void execute(DCmdSource source, TRAPS);
241 };
242
243 class VMInfoDCmd : public DCmd {
244 public:
245 VMInfoDCmd(outputStream* output, bool heap) : DCmd(output, heap) { }
246 static const char* name() { return "VM.info"; }
247 static const char* description() {
248 return "Print information about JVM environment and status.";
249 }
250 static const char* impact() { return "Low"; }
251 static const JavaPermission permission() {
252 JavaPermission p = {"java.lang.management.ManagementPermission",
253 "monitor", NULL};
254 return p;
255 }
256 static int num_arguments() { return 0; }
257 virtual void execute(DCmdSource source, TRAPS);
258 };
259
260 class SystemGCDCmd : public DCmd {
261 public:
262 SystemGCDCmd(outputStream* output, bool heap) : DCmd(output, heap) { }
263 static const char* name() { return "GC.run"; }
264 static const char* description() {
265 return "Call java.lang.System.gc().";
266 }
267 static const char* impact() {
268 return "Medium: Depends on Java heap size and content.";
269 }
270 static int num_arguments() { return 0; }
271 virtual void execute(DCmdSource source, TRAPS);
272 };
273
274 class RunFinalizationDCmd : public DCmd {
275 public:
276 RunFinalizationDCmd(outputStream* output, bool heap) : DCmd(output, heap) { }
277 static const char* name() { return "GC.run_finalization"; }
278 static const char* description() {
279 return "Call java.lang.System.runFinalization().";
280 }
281 static const char* impact() {
282 return "Medium: Depends on Java content.";
283 }
284 static int num_arguments() { return 0; }
285 virtual void execute(DCmdSource source, TRAPS);
286 };
287
288 class HeapInfoDCmd : public DCmd {
289 public:
290 HeapInfoDCmd(outputStream* output, bool heap) : DCmd(output, heap) { }
291 static const char* name() { return "GC.heap_info"; }
292 static const char* description() {
293 return "Provide generic Java heap information.";
294 }
295 static const char* impact() {
296 return "Medium";
297 }
298 static int num_arguments() { return 0; }
299 static const JavaPermission permission() {
300 JavaPermission p = {"java.lang.management.ManagementPermission",
301 "monitor", NULL};
302 return p;
303 }
304
305 virtual void execute(DCmdSource source, TRAPS);
306 };
307
308 class FinalizerInfoDCmd : public DCmd {
309 public:
310 FinalizerInfoDCmd(outputStream* output, bool heap) : DCmd(output, heap) { }
311 static const char* name() { return "GC.finalizer_info"; }
312 static const char* description() {
313 return "Provide information about Java finalization queue.";
314 }
315 static const char* impact() {
316 return "Medium";
317 }
318 static int num_arguments() { return 0; }
319 static const JavaPermission permission() {
320 JavaPermission p = {"java.lang.management.ManagementPermission",
321 "monitor", NULL};
322 return p;
323 }
324
325 virtual void execute(DCmdSource source, TRAPS);
326 };
327
328 #if INCLUDE_SERVICES // Heap dumping supported
329 // See also: dump_heap in attachListener.cpp
330 class HeapDumpDCmd : public DCmdWithParser {
331 protected:
332 DCmdArgument<char*> _filename;
333 DCmdArgument<bool> _all;
334 public:
335 HeapDumpDCmd(outputStream* output, bool heap);
336 static const char* name() {
337 return "GC.heap_dump";
338 }
339 static const char* description() {
340 return "Generate a HPROF format dump of the Java heap.";
341 }
342 static const char* impact() {
343 return "High: Depends on Java heap size and content. "
344 "Request a full GC unless the '-all' option is specified.";
345 }
346 static const JavaPermission permission() {
347 JavaPermission p = {"java.lang.management.ManagementPermission",
348 "monitor", NULL};
349 return p;
350 }
351 static int num_arguments();
352 virtual void execute(DCmdSource source, TRAPS);
353 };
354 #endif // INCLUDE_SERVICES
355
356 // See also: inspectheap in attachListener.cpp
357 class ClassHistogramDCmd : public DCmdWithParser {
358 protected:
359 DCmdArgument<bool> _all;
360 public:
361 ClassHistogramDCmd(outputStream* output, bool heap);
362 static const char* name() {
363 return "GC.class_histogram";
364 }
365 static const char* description() {
366 return "Provide statistics about the Java heap usage.";
367 }
368 static const char* impact() {
369 return "High: Depends on Java heap size and content.";
370 }
371 static const JavaPermission permission() {
372 JavaPermission p = {"java.lang.management.ManagementPermission",
373 "monitor", NULL};
374 return p;
375 }
376 static int num_arguments();
377 virtual void execute(DCmdSource source, TRAPS);
378 };
379
380 class ClassStatsDCmd : public DCmdWithParser {
381 protected:
382 DCmdArgument<bool> _all;
383 DCmdArgument<bool> _csv;
384 DCmdArgument<bool> _help;
385 DCmdArgument<char*> _columns;
386 public:
387 ClassStatsDCmd(outputStream* output, bool heap);
388 static const char* name() {
389 return "GC.class_stats";
390 }
391 static const char* description() {
392 return "Provide statistics about Java class meta data.";
393 }
394 static const char* impact() {
395 return "High: Depends on Java heap size and content.";
396 }
397 static int num_arguments();
398 virtual void execute(DCmdSource source, TRAPS);
399 };
400
401
402 class ClassHierarchyDCmd : public DCmdWithParser {
403 protected:
404 DCmdArgument<bool> _print_interfaces; // true if inherited interfaces should be printed.
405 DCmdArgument<bool> _print_subclasses; // true if subclasses of the specified classname should be printed.
406 DCmdArgument<char*> _classname; // Optional single class name whose hierarchy should be printed.
407 public:
408 ClassHierarchyDCmd(outputStream* output, bool heap);
409 static const char* name() {
410 return "VM.class_hierarchy";
411 }
412 static const char* description() {
413 return "Print a list of all loaded classes, indented to show the class hiearchy. "
414 "The name of each class is followed by the ClassLoaderData* of its ClassLoader, "
415 "or \"null\" if loaded by the bootstrap class loader.";
416 }
417 static const char* impact() {
418 return "Medium: Depends on number of loaded classes.";
419 }
420 static const JavaPermission permission() {
421 JavaPermission p = {"java.lang.management.ManagementPermission",
422 "monitor", NULL};
423 return p;
424 }
425 static int num_arguments();
426 virtual void execute(DCmdSource source, TRAPS);
427 };
428
429 class TouchedMethodsDCmd : public DCmdWithParser {
430 public:
431 TouchedMethodsDCmd(outputStream* output, bool heap);
432 static const char* name() {
433 return "VM.print_touched_methods";
434 }
435 static const char* description() {
436 return "Print all methods that have ever been touched during the lifetime of this JVM.";
437 }
438 static const char* impact() {
439 return "Medium: Depends on Java content.";
440 }
441 static int num_arguments();
442 virtual void execute(DCmdSource source, TRAPS);
443 };
444
445 // See also: thread_dump in attachListener.cpp
446 class ThreadDumpDCmd : public DCmdWithParser {
447 protected:
448 DCmdArgument<bool> _locks;
449 public:
450 ThreadDumpDCmd(outputStream* output, bool heap);
451 static const char* name() { return "Thread.print"; }
452 static const char* description() {
453 return "Print all threads with stacktraces.";
454 }
455 static const char* impact() {
456 return "Medium: Depends on the number of threads.";
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();
464 virtual void execute(DCmdSource source, TRAPS);
465 };
466
467 // Enhanced JMX Agent support
468
469 class JMXStartRemoteDCmd : public DCmdWithParser {
470
471 // Explicitly list all properties that could be
472 // passed to Agent.startRemoteManagementAgent()
473 // com.sun.management is omitted
474
475 DCmdArgument<char *> _config_file;
476 DCmdArgument<char *> _jmxremote_host;
477 DCmdArgument<char *> _jmxremote_port;
478 DCmdArgument<char *> _jmxremote_rmi_port;
479 DCmdArgument<char *> _jmxremote_ssl;
480 DCmdArgument<char *> _jmxremote_registry_ssl;
481 DCmdArgument<char *> _jmxremote_authenticate;
482 DCmdArgument<char *> _jmxremote_password_file;
483 DCmdArgument<char *> _jmxremote_access_file;
484 DCmdArgument<char *> _jmxremote_login_config;
485 DCmdArgument<char *> _jmxremote_ssl_enabled_cipher_suites;
486 DCmdArgument<char *> _jmxremote_ssl_enabled_protocols;
487 DCmdArgument<char *> _jmxremote_ssl_need_client_auth;
488 DCmdArgument<char *> _jmxremote_ssl_config_file;
489
490 // JDP support
491 // Keep autodiscovery char* not bool to pass true/false
492 // as property value to java level.
493 DCmdArgument<char *> _jmxremote_autodiscovery;
494 DCmdArgument<jlong> _jdp_port;
495 DCmdArgument<char *> _jdp_address;
496 DCmdArgument<char *> _jdp_source_addr;
497 DCmdArgument<jlong> _jdp_ttl;
498 DCmdArgument<jlong> _jdp_pause;
499 DCmdArgument<char *> _jdp_name;
500
501 public:
502 JMXStartRemoteDCmd(outputStream *output, bool heap_allocated);
503
504 static const char *name() {
505 return "ManagementAgent.start";
506 }
507
508 static const char *description() {
509 return "Start remote management agent.";
510 }
511
512 static int num_arguments();
513
514 virtual void execute(DCmdSource source, TRAPS);
515
516 };
517
518 class JMXStartLocalDCmd : public DCmd {
519
520 // Explicitly request start of local agent,
521 // it will not be started by start dcmd
522
523
524 public:
525 JMXStartLocalDCmd(outputStream *output, bool heap_allocated);
526
527 static const char *name() {
528 return "ManagementAgent.start_local";
529 }
530
531 static const char *description() {
532 return "Start local management agent.";
533 }
534
535 virtual void execute(DCmdSource source, TRAPS);
536
537 };
538
539 class JMXStopRemoteDCmd : public DCmd {
540 public:
541 JMXStopRemoteDCmd(outputStream *output, bool heap_allocated) :
542 DCmd(output, heap_allocated) {
543 // Do Nothing
544 }
545
546 static const char *name() {
547 return "ManagementAgent.stop";
548 }
549
550 static const char *description() {
551 return "Stop remote management agent.";
552 }
553
554 virtual void execute(DCmdSource source, TRAPS);
555 };
556
557 // Print the JMX system status
558 class JMXStatusDCmd : public DCmd {
559 public:
560 JMXStatusDCmd(outputStream *output, bool heap_allocated);
561
562 static const char *name() {
563 return "ManagementAgent.status";
564 }
565
566 static const char *description() {
567 return "Print the management agent status.";
568 }
569
570 static const JavaPermission permission() {
571 JavaPermission p = {"java.lang.management.ManagementPermission",
572 "monitor", NULL};
573 return p;
574 }
575
576 virtual void execute(DCmdSource source, TRAPS);
577
578 };
579
580 class CompileQueueDCmd : public DCmd {
581 public:
582 CompileQueueDCmd(outputStream* output, bool heap) : DCmd(output, heap) {}
583 static const char* name() {
584 return "Compiler.queue";
585 }
586 static const char* description() {
587 return "Print methods queued for compilation.";
588 }
589 static const char* impact() {
590 return "Low";
591 }
592 static const JavaPermission permission() {
593 JavaPermission p = {"java.lang.management.ManagementPermission",
594 "monitor", NULL};
595 return p;
596 }
597 static int num_arguments() { return 0; }
598 virtual void execute(DCmdSource source, TRAPS);
599 };
600
601 class CodeListDCmd : public DCmd {
602 public:
603 CodeListDCmd(outputStream* output, bool heap) : DCmd(output, heap) {}
604 static const char* name() {
605 return "Compiler.codelist";
606 }
607 static const char* description() {
608 return "Print all compiled methods in code cache that are alive";
609 }
610 static const char* impact() {
611 return "Medium";
612 }
613 static const JavaPermission permission() {
614 JavaPermission p = {"java.lang.management.ManagementPermission",
615 "monitor", NULL};
616 return p;
617 }
618 static int num_arguments() { return 0; }
619 virtual void execute(DCmdSource source, TRAPS);
620 };
621
622
623 class CodeCacheDCmd : public DCmd {
624 public:
625 CodeCacheDCmd(outputStream* output, bool heap) : DCmd(output, heap) {}
626 static const char* name() {
627 return "Compiler.codecache";
628 }
629 static const char* description() {
630 return "Print code cache layout and bounds.";
631 }
632 static const char* impact() {
633 return "Low";
634 }
635 static const JavaPermission permission() {
636 JavaPermission p = {"java.lang.management.ManagementPermission",
637 "monitor", NULL};
638 return p;
639 }
640 static int num_arguments() { return 0; }
641 virtual void execute(DCmdSource source, TRAPS);
642 };
643
644 class CompilerDirectivesPrintDCmd : public DCmd {
645 public:
646 CompilerDirectivesPrintDCmd(outputStream* output, bool heap) : DCmd(output, heap) {}
647 static const char* name() {
648 return "Compiler.directives_print";
649 }
650 static const char* description() {
651 return "Print all active compiler directives.";
652 }
653 static const char* impact() {
654 return "Low";
655 }
656 static const JavaPermission permission() {
657 JavaPermission p = {"java.lang.management.ManagementPermission",
658 "monitor", NULL};
659 return p;
660 }
661 static int num_arguments() { return 0; }
662 virtual void execute(DCmdSource source, TRAPS);
663 };
664
665 class CompilerDirectivesRemoveDCmd : public DCmd {
666 public:
667 CompilerDirectivesRemoveDCmd(outputStream* output, bool heap) : DCmd(output, heap) {}
668 static const char* name() {
669 return "Compiler.directives_remove";
670 }
671 static const char* description() {
672 return "Remove latest added compiler directive.";
673 }
674 static const char* impact() {
675 return "Low";
676 }
677 static const JavaPermission permission() {
678 JavaPermission p = {"java.lang.management.ManagementPermission",
679 "monitor", NULL};
680 return p;
681 }
682 static int num_arguments() { return 0; }
683 virtual void execute(DCmdSource source, TRAPS);
684 };
685
686 class CompilerDirectivesAddDCmd : public DCmdWithParser {
687 protected:
688 DCmdArgument<char*> _filename;
689 public:
690 CompilerDirectivesAddDCmd(outputStream* output, bool heap);
691 static const char* name() {
692 return "Compiler.directives_add";
693 }
694 static const char* description() {
695 return "Add compiler directives from file.";
696 }
697 static const char* impact() {
698 return "Low";
699 }
700 static const JavaPermission permission() {
701 JavaPermission p = {"java.lang.management.ManagementPermission",
702 "monitor", NULL};
703 return p;
704 }
705 static int num_arguments();
706 virtual void execute(DCmdSource source, TRAPS);
707 };
708
709 class CompilerDirectivesClearDCmd : public DCmd {
710 public:
711 CompilerDirectivesClearDCmd(outputStream* output, bool heap) : DCmd(output, heap) {}
712 static const char* name() {
713 return "Compiler.directives_clear";
714 }
715 static const char* description() {
716 return "Remove all compiler directives.";
717 }
718 static const char* impact() {
719 return "Low";
720 }
721 static const JavaPermission permission() {
722 JavaPermission p = {"java.lang.management.ManagementPermission",
723 "monitor", NULL};
724 return p;
725 }
726 static int num_arguments() { return 0; }
727 virtual void execute(DCmdSource source, TRAPS);
728 };
729
730 ///////////////////////////////////////////////////////////////////////
731 //
732 // jcmd command support for symbol table, string table and system dictionary dumping:
733 // VM.symboltable -verbose: for dumping the symbol table
734 // VM.stringtable -verbose: for dumping the string table
735 // VM.systemdictionary -verbose: for dumping the system dictionary table
736 //
737 class VM_DumpHashtable : public VM_Operation {
738 private:
739 outputStream* _out;
740 int _which;
741 bool _verbose;
742 public:
743 enum {
744 DumpSymbols = 1 << 0,
745 DumpStrings = 1 << 1,
746 DumpSysDict = 1 << 2 // not implemented yet
747 };
748 VM_DumpHashtable(outputStream* out, int which, bool verbose) {
749 _out = out;
750 _which = which;
751 _verbose = verbose;
752 }
753
754 virtual VMOp_Type type() const { return VMOp_DumpHashtable; }
755
756 virtual void doit() {
757 switch (_which) {
758 case DumpSymbols:
759 SymbolTable::dump(_out, _verbose);
760 break;
761 case DumpStrings:
762 StringTable::dump(_out, _verbose);
763 break;
764 case DumpSysDict:
765 SystemDictionary::dump(_out, _verbose);
766 break;
767 default:
768 ShouldNotReachHere();
769 }
770 }
771 };
772
773 class SymboltableDCmd : public DCmdWithParser {
774 protected:
775 DCmdArgument<bool> _verbose;
776 public:
777 SymboltableDCmd(outputStream* output, bool heap);
778 static const char* name() {
779 return "VM.symboltable";
780 }
781 static const char* description() {
782 return "Dump symbol table.";
783 }
784 static const char* impact() {
785 return "Medium: Depends on Java content.";
786 }
787 static const JavaPermission permission() {
788 JavaPermission p = {"java.lang.management.ManagementPermission",
789 "monitor", NULL};
790 return p;
791 }
792 static int num_arguments();
793 virtual void execute(DCmdSource source, TRAPS);
794 };
795
796 class StringtableDCmd : public DCmdWithParser {
797 protected:
798 DCmdArgument<bool> _verbose;
799 public:
800 StringtableDCmd(outputStream* output, bool heap);
801 static const char* name() {
802 return "VM.stringtable";
803 }
804 static const char* description() {
805 return "Dump string table.";
806 }
807 static const char* impact() {
808 return "Medium: Depends on Java content.";
809 }
810 static const JavaPermission permission() {
811 JavaPermission p = {"java.lang.management.ManagementPermission",
812 "monitor", NULL};
813 return p;
814 }
815 static int num_arguments();
816 virtual void execute(DCmdSource source, TRAPS);
817 };
818
819 class SystemDictionaryDCmd : public DCmdWithParser {
820 protected:
821 DCmdArgument<bool> _verbose;
822 public:
823 SystemDictionaryDCmd(outputStream* output, bool heap);
824 static const char* name() {
825 return "VM.systemdictionary";
826 }
827 static const char* description() {
828 return "Prints the statistics for dictionary hashtable sizes and bucket length";
829 }
830 static const char* impact() {
831 return "Medium: Depends on Java content.";
832 }
833 static const JavaPermission permission() {
834 JavaPermission p = {"java.lang.management.ManagementPermission",
835 "monitor", NULL};
836 return p;
837 }
838 static int num_arguments();
839 virtual void execute(DCmdSource source, TRAPS);
840 };
841
842 class MetaspaceDCmd : public DCmd {
843 public:
844 MetaspaceDCmd(outputStream* output, bool heap);
845 static const char* name() {
846 return "VM.metaspace";
847 }
848 static const char* description() {
849 return "Prints the statistics for the metaspace";
850 }
851 static const char* impact() {
852 return "Medium: Depends on number of classes loaded.";
853 }
854 static const JavaPermission permission() {
855 JavaPermission p = {"java.lang.management.ManagementPermission",
856 "monitor", NULL};
857 return p;
858 }
859 static int num_arguments() { return 0; }
860 virtual void execute(DCmdSource source, TRAPS);
861 };
862
863 #endif // SHARE_VM_SERVICES_DIAGNOSTICCOMMAND_HPP