rev 49736 : [mq]: metaspace-additions-to-jcmd
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 //---< BEGIN >--- CodeHeap State Analytics.
645 class CodeHeapAnalyticsDCmd : public DCmdWithParser {
646 protected:
647 DCmdArgument<char*> _function;
648 DCmdArgument<char*> _granularity;
649 public:
650 CodeHeapAnalyticsDCmd(outputStream* output, bool heap);
651 static const char* name() {
652 return "Compiler.CodeHeap_Analytics";
653 }
654 static const char* description() {
655 return "Print CodeHeap analytics";
656 }
657 static const char* impact() {
658 return "Low: Depends on code heap size and content. "
659 "Holds CodeCache_lock during analysis step, usually sub-second duration.";
660 }
661 static const JavaPermission permission() {
662 JavaPermission p = {"java.lang.management.ManagementPermission",
663 "monitor", NULL};
664 return p;
665 }
666 static int num_arguments();
667 virtual void execute(DCmdSource source, TRAPS);
668 };
669 //---< END >--- CodeHeap State Analytics.
670
671 class CompilerDirectivesPrintDCmd : public DCmd {
672 public:
673 CompilerDirectivesPrintDCmd(outputStream* output, bool heap) : DCmd(output, heap) {}
674 static const char* name() {
675 return "Compiler.directives_print";
676 }
677 static const char* description() {
678 return "Print all active compiler directives.";
679 }
680 static const char* impact() {
681 return "Low";
682 }
683 static const JavaPermission permission() {
684 JavaPermission p = {"java.lang.management.ManagementPermission",
685 "monitor", NULL};
686 return p;
687 }
688 static int num_arguments() { return 0; }
689 virtual void execute(DCmdSource source, TRAPS);
690 };
691
692 class CompilerDirectivesRemoveDCmd : public DCmd {
693 public:
694 CompilerDirectivesRemoveDCmd(outputStream* output, bool heap) : DCmd(output, heap) {}
695 static const char* name() {
696 return "Compiler.directives_remove";
697 }
698 static const char* description() {
699 return "Remove latest added compiler directive.";
700 }
701 static const char* impact() {
702 return "Low";
703 }
704 static const JavaPermission permission() {
705 JavaPermission p = {"java.lang.management.ManagementPermission",
706 "monitor", NULL};
707 return p;
708 }
709 static int num_arguments() { return 0; }
710 virtual void execute(DCmdSource source, TRAPS);
711 };
712
713 class CompilerDirectivesAddDCmd : public DCmdWithParser {
714 protected:
715 DCmdArgument<char*> _filename;
716 public:
717 CompilerDirectivesAddDCmd(outputStream* output, bool heap);
718 static const char* name() {
719 return "Compiler.directives_add";
720 }
721 static const char* description() {
722 return "Add compiler directives from file.";
723 }
724 static const char* impact() {
725 return "Low";
726 }
727 static const JavaPermission permission() {
728 JavaPermission p = {"java.lang.management.ManagementPermission",
729 "monitor", NULL};
730 return p;
731 }
732 static int num_arguments();
733 virtual void execute(DCmdSource source, TRAPS);
734 };
735
736 class CompilerDirectivesClearDCmd : public DCmd {
737 public:
738 CompilerDirectivesClearDCmd(outputStream* output, bool heap) : DCmd(output, heap) {}
739 static const char* name() {
740 return "Compiler.directives_clear";
741 }
742 static const char* description() {
743 return "Remove all compiler directives.";
744 }
745 static const char* impact() {
746 return "Low";
747 }
748 static const JavaPermission permission() {
749 JavaPermission p = {"java.lang.management.ManagementPermission",
750 "monitor", NULL};
751 return p;
752 }
753 static int num_arguments() { return 0; }
754 virtual void execute(DCmdSource source, TRAPS);
755 };
756
757 ///////////////////////////////////////////////////////////////////////
758 //
759 // jcmd command support for symbol table, string table and system dictionary dumping:
760 // VM.symboltable -verbose: for dumping the symbol table
761 // VM.stringtable -verbose: for dumping the string table
762 // VM.systemdictionary -verbose: for dumping the system dictionary table
763 //
764 class VM_DumpHashtable : public VM_Operation {
765 private:
766 outputStream* _out;
767 int _which;
768 bool _verbose;
769 public:
770 enum {
771 DumpSymbols = 1 << 0,
772 DumpStrings = 1 << 1,
773 DumpSysDict = 1 << 2 // not implemented yet
774 };
775 VM_DumpHashtable(outputStream* out, int which, bool verbose) {
776 _out = out;
777 _which = which;
778 _verbose = verbose;
779 }
780
781 virtual VMOp_Type type() const { return VMOp_DumpHashtable; }
782
783 virtual void doit() {
784 switch (_which) {
785 case DumpSymbols:
786 SymbolTable::dump(_out, _verbose);
787 break;
788 case DumpStrings:
789 StringTable::dump(_out, _verbose);
790 break;
791 case DumpSysDict:
792 SystemDictionary::dump(_out, _verbose);
793 break;
794 default:
795 ShouldNotReachHere();
796 }
797 }
798 };
799
800 class SymboltableDCmd : public DCmdWithParser {
801 protected:
802 DCmdArgument<bool> _verbose;
803 public:
804 SymboltableDCmd(outputStream* output, bool heap);
805 static const char* name() {
806 return "VM.symboltable";
807 }
808 static const char* description() {
809 return "Dump symbol table.";
810 }
811 static const char* impact() {
812 return "Medium: Depends on Java content.";
813 }
814 static const JavaPermission permission() {
815 JavaPermission p = {"java.lang.management.ManagementPermission",
816 "monitor", NULL};
817 return p;
818 }
819 static int num_arguments();
820 virtual void execute(DCmdSource source, TRAPS);
821 };
822
823 class StringtableDCmd : public DCmdWithParser {
824 protected:
825 DCmdArgument<bool> _verbose;
826 public:
827 StringtableDCmd(outputStream* output, bool heap);
828 static const char* name() {
829 return "VM.stringtable";
830 }
831 static const char* description() {
832 return "Dump string table.";
833 }
834 static const char* impact() {
835 return "Medium: Depends on Java content.";
836 }
837 static const JavaPermission permission() {
838 JavaPermission p = {"java.lang.management.ManagementPermission",
839 "monitor", NULL};
840 return p;
841 }
842 static int num_arguments();
843 virtual void execute(DCmdSource source, TRAPS);
844 };
845
846 class SystemDictionaryDCmd : public DCmdWithParser {
847 protected:
848 DCmdArgument<bool> _verbose;
849 public:
850 SystemDictionaryDCmd(outputStream* output, bool heap);
851 static const char* name() {
852 return "VM.systemdictionary";
853 }
854 static const char* description() {
855 return "Prints the statistics for dictionary hashtable sizes and bucket length";
856 }
857 static const char* impact() {
858 return "Medium: Depends on Java content.";
859 }
860 static const JavaPermission permission() {
861 JavaPermission p = {"java.lang.management.ManagementPermission",
862 "monitor", NULL};
863 return p;
864 }
865 static int num_arguments();
866 virtual void execute(DCmdSource source, TRAPS);
867 };
868
869 class MetaspaceDCmd : public DCmd {
870 public:
871 MetaspaceDCmd(outputStream* output, bool heap);
872 static const char* name() {
873 return "VM.metaspace";
874 }
875 static const char* description() {
876 return "Prints the statistics for the metaspace";
877 }
878 static const char* impact() {
879 return "Medium: Depends on number of classes loaded.";
880 }
881 static const JavaPermission permission() {
882 JavaPermission p = {"java.lang.management.ManagementPermission",
883 "monitor", NULL};
884 return p;
885 }
886 static int num_arguments() { return 0; }
887 virtual void execute(DCmdSource source, TRAPS);
888 };
889
890 #endif // SHARE_VM_SERVICES_DIAGNOSTICCOMMAND_HPP
--- EOF ---