1 /*
2 * Copyright (c) 2011, 2023, 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_SERVICES_DIAGNOSTICCOMMAND_HPP
26 #define SHARE_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/diagnosticFramework.hpp"
38 #include "utilities/macros.hpp"
39 #include "utilities/ostream.hpp"
40 #include "oops/method.hpp"
41
42 class HelpDCmd : public DCmdWithParser {
43 protected:
44 DCmdArgument<bool> _all;
45 DCmdArgument<char*> _cmd;
46 public:
47 static int num_arguments() { return 2; }
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 virtual void execute(DCmdSource source, TRAPS);
57 };
58
59 class VersionDCmd : public DCmd {
60 public:
61 VersionDCmd(outputStream* output, bool heap) : DCmd(output,heap) { }
62 static const char* name() { return "VM.version"; }
63 static const char* description() {
64 return "Print JVM version information.";
65 }
66 static const char* impact() { return "Low"; }
67 static const JavaPermission permission() {
68 JavaPermission p = {"java.util.PropertyPermission",
69 "java.vm.version", "read"};
70 return p;
71 }
72 virtual void execute(DCmdSource source, TRAPS);
73 };
74
75 class CommandLineDCmd : public DCmd {
76 public:
77 CommandLineDCmd(outputStream* output, bool heap) : DCmd(output, heap) { }
78 static const char* name() { return "VM.command_line"; }
79 static const char* description() {
80 return "Print the command line used to start this VM instance.";
81 }
82 static const char* impact() { return "Low"; }
83 static const JavaPermission permission() {
84 JavaPermission p = {"java.lang.management.ManagementPermission",
85 "monitor", nullptr};
86 return p;
87 }
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 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 static int num_arguments() { return 1; }
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", nullptr};
129 return p;
130 }
131 virtual void execute(DCmdSource source, TRAPS);
132 };
133
134 class SetVMFlagDCmd : public DCmdWithParser {
135 protected:
136 DCmdArgument<char*> _flag;
137 DCmdArgument<char*> _value;
138
139 public:
140 static int num_arguments() { return 2; }
141 SetVMFlagDCmd(outputStream* output, bool heap);
142 static const char* name() { return "VM.set_flag"; }
143 static const char* description() {
144 return "Sets VM flag option using the provided value.";
145 }
146 static const char* impact() {
147 return "Low";
148 }
149 static const JavaPermission permission() {
150 JavaPermission p = {"java.lang.management.ManagementPermission",
151 "control", nullptr};
152 return p;
153 }
154 virtual void execute(DCmdSource source, TRAPS);
155 };
156
157 class JVMTIDataDumpDCmd : public DCmd {
158 public:
159 JVMTIDataDumpDCmd(outputStream* output, bool heap) : DCmd(output, heap) { }
160 static const char* name() { return "JVMTI.data_dump"; }
161 static const char* description() {
162 return "Signal the JVM to do a data-dump request for JVMTI.";
163 }
164 static const char* impact() {
165 return "High";
166 }
167 static const JavaPermission permission() {
168 JavaPermission p = {"java.lang.management.ManagementPermission",
169 "monitor", nullptr};
170 return p;
171 }
172 virtual void execute(DCmdSource source, TRAPS);
173 };
174
175 #if INCLUDE_SERVICES
176 #if INCLUDE_JVMTI
177 class JVMTIAgentLoadDCmd : public DCmdWithParser {
178 protected:
179 DCmdArgument<char*> _libpath;
180 DCmdArgument<char*> _option;
181 public:
182 static int num_arguments() { return 2; }
183 JVMTIAgentLoadDCmd(outputStream* output, bool heap);
184 static const char* name() { return "JVMTI.agent_load"; }
185 static const char* description() {
186 return "Load JVMTI native agent.";
187 }
188 static const char* impact() { return "Low"; }
189 static const JavaPermission permission() {
190 JavaPermission p = {"java.lang.management.ManagementPermission",
191 "control", nullptr};
192 return p;
193 }
194 virtual void execute(DCmdSource source, TRAPS);
195 };
196 #endif // INCLUDE_JVMTI
197 #endif // INCLUDE_SERVICES
198
199 class VMDynamicLibrariesDCmd : public DCmd {
200 public:
201 VMDynamicLibrariesDCmd(outputStream* output, bool heap);
202 static const char* name() {
203 return "VM.dynlibs";
204 }
205 static const char* description() {
206 return "Print loaded dynamic libraries.";
207 }
208 static const char* impact() {
209 return "Low";
210 }
211 static const JavaPermission permission() {
212 JavaPermission p = {"java.lang.management.ManagementPermission",
213 "monitor", nullptr};
214 return p;
215 }
216 virtual void execute(DCmdSource source, TRAPS);
217 };
218
219 class VMUptimeDCmd : public DCmdWithParser {
220 protected:
221 DCmdArgument<bool> _date;
222 public:
223 static int num_arguments() { return 1; }
224 VMUptimeDCmd(outputStream* output, bool heap);
225 static const char* name() { return "VM.uptime"; }
226 static const char* description() {
227 return "Print VM uptime.";
228 }
229 static const char* impact() {
230 return "Low";
231 }
232 virtual void execute(DCmdSource source, TRAPS);
233 };
234
235 class VMInfoDCmd : public DCmd {
236 public:
237 VMInfoDCmd(outputStream* output, bool heap) : DCmd(output, heap) { }
238 static const char* name() { return "VM.info"; }
239 static const char* description() {
240 return "Print information about JVM environment and status.";
241 }
242 static const char* impact() { return "Low"; }
243 static const JavaPermission permission() {
244 JavaPermission p = {"java.lang.management.ManagementPermission",
245 "monitor", nullptr};
246 return p;
247 }
248 virtual void execute(DCmdSource source, TRAPS);
249 };
250
251 class SystemGCDCmd : public DCmd {
252 public:
253 SystemGCDCmd(outputStream* output, bool heap) : DCmd(output, heap) { }
254 static const char* name() { return "GC.run"; }
255 static const char* description() {
256 return "Call java.lang.System.gc().";
257 }
258 static const char* impact() {
259 return "Medium: Depends on Java heap size and content.";
260 }
261 virtual void execute(DCmdSource source, TRAPS);
262 };
263
264 class RunFinalizationDCmd : public DCmd {
265 public:
266 RunFinalizationDCmd(outputStream* output, bool heap) : DCmd(output, heap) { }
267 static const char* name() { return "GC.run_finalization"; }
268 static const char* description() {
269 return "Call java.lang.System.runFinalization().";
270 }
271 static const char* impact() {
272 return "Medium: Depends on Java content.";
273 }
274 virtual void execute(DCmdSource source, TRAPS);
275 };
276
277 class HeapInfoDCmd : public DCmd {
278 public:
279 HeapInfoDCmd(outputStream* output, bool heap) : DCmd(output, heap) { }
280 static const char* name() { return "GC.heap_info"; }
281 static const char* description() {
282 return "Provide generic Java heap information.";
283 }
284 static const char* impact() {
285 return "Medium";
286 }
287 static const JavaPermission permission() {
288 JavaPermission p = {"java.lang.management.ManagementPermission",
289 "monitor", nullptr};
290 return p;
291 }
292
293 virtual void execute(DCmdSource source, TRAPS);
294 };
295
296 class FinalizerInfoDCmd : public DCmd {
297 public:
298 FinalizerInfoDCmd(outputStream* output, bool heap) : DCmd(output, heap) { }
299 static const char* name() { return "GC.finalizer_info"; }
300 static const char* description() {
301 return "Provide information about Java finalization queue.";
302 }
303 static const char* impact() {
304 return "Medium";
305 }
306 static const JavaPermission permission() {
307 JavaPermission p = {"java.lang.management.ManagementPermission",
308 "monitor", nullptr};
309 return p;
310 }
311
312 virtual void execute(DCmdSource source, TRAPS);
313 };
314
315 #if INCLUDE_SERVICES // Heap dumping supported
316 // See also: dump_heap in attachListener.cpp
317 class HeapDumpDCmd : public DCmdWithParser {
318 protected:
319 DCmdArgument<char*> _filename;
320 DCmdArgument<bool> _all;
321 DCmdArgument<jlong> _gzip;
322 DCmdArgument<bool> _overwrite;
323 DCmdArgument<jlong> _parallel;
324 public:
325 static int num_arguments() { return 5; }
326 HeapDumpDCmd(outputStream* output, bool heap);
327 static const char* name() {
328 return "GC.heap_dump";
329 }
330 static const char* description() {
331 return "Generate a HPROF format dump of the Java heap.";
332 }
333 static const char* impact() {
334 return "High: Depends on Java heap size and content. "
335 "Request a full GC unless the '-all' option is specified.";
336 }
337 static const JavaPermission permission() {
338 JavaPermission p = {"java.lang.management.ManagementPermission",
339 "monitor", nullptr};
340 return p;
341 }
342 virtual void execute(DCmdSource source, TRAPS);
343 };
344 #endif // INCLUDE_SERVICES
345
346 // See also: inspectheap in attachListener.cpp
347 class ClassHistogramDCmd : public DCmdWithParser {
348 protected:
349 DCmdArgument<bool> _all;
350 DCmdArgument<jlong> _parallel_thread_num;
351 public:
352 static int num_arguments() { return 2; }
353 ClassHistogramDCmd(outputStream* output, bool heap);
354 static const char* name() {
355 return "GC.class_histogram";
356 }
357 static const char* description() {
358 return "Provide statistics about the Java heap usage.";
359 }
360 static const char* impact() {
361 return "High: Depends on Java heap size and content.";
362 }
363 static const JavaPermission permission() {
364 JavaPermission p = {"java.lang.management.ManagementPermission",
365 "monitor", nullptr};
366 return p;
367 }
368 virtual void execute(DCmdSource source, TRAPS);
369 };
370
371 class ClassHierarchyDCmd : public DCmdWithParser {
372 protected:
373 DCmdArgument<bool> _print_interfaces; // true if inherited interfaces should be printed.
374 DCmdArgument<bool> _print_subclasses; // true if subclasses of the specified classname should be printed.
375 DCmdArgument<char*> _classname; // Optional single class name whose hierarchy should be printed.
376 public:
377 static int num_arguments() { return 3; }
378 ClassHierarchyDCmd(outputStream* output, bool heap);
379 static const char* name() {
380 return "VM.class_hierarchy";
381 }
382 static const char* description() {
383 return "Print a list of all loaded classes, indented to show the class hierarchy. "
384 "The name of each class is followed by the ClassLoaderData* of its ClassLoader, "
385 "or \"null\" if loaded by the bootstrap class loader.";
386 }
387 static const char* impact() {
388 return "Medium: Depends on number of loaded classes.";
389 }
390 static const JavaPermission permission() {
391 JavaPermission p = {"java.lang.management.ManagementPermission",
392 "monitor", nullptr};
393 return p;
394 }
395 virtual void execute(DCmdSource source, TRAPS);
396 };
397
398 #if INCLUDE_CDS
399 class DumpSharedArchiveDCmd: public DCmdWithParser {
400 protected:
401 DCmdArgument<char*> _suboption; // option of VM.cds
402 DCmdArgument<char*> _filename; // file name, optional
403 public:
404 static int num_arguments() { return 2; }
405 DumpSharedArchiveDCmd(outputStream* output, bool heap);
406 static const char* name() {
407 return "VM.cds";
408 }
409 static const char* description() {
410 return "Dump a static or dynamic shared archive including all shareable classes";
411 }
412 static const char* impact() {
413 return "Medium: Pause time depends on number of loaded classes";
414 }
415 static const JavaPermission permission() {
416 JavaPermission p = {"java.lang.management.ManagementPermission",
417 "monitor", nullptr};
418 return p;
419 }
420 virtual void execute(DCmdSource source, TRAPS);
421 };
422 #endif // INCLUDE_CDS
423
424 // See also: thread_dump in attachListener.cpp
425 class ThreadDumpDCmd : public DCmdWithParser {
426 protected:
427 DCmdArgument<bool> _locks;
428 DCmdArgument<bool> _extended;
429 public:
430 static int num_arguments() { return 2; }
431 ThreadDumpDCmd(outputStream* output, bool heap);
432 static const char* name() { return "Thread.print"; }
433 static const char* description() {
434 return "Print all threads with stacktraces.";
435 }
436 static const char* impact() {
437 return "Medium: Depends on the number of threads.";
438 }
439 static const JavaPermission permission() {
440 JavaPermission p = {"java.lang.management.ManagementPermission",
441 "monitor", nullptr};
442 return p;
443 }
444 virtual void execute(DCmdSource source, TRAPS);
445 };
446
447 // Enhanced JMX Agent support
448
449 class JMXStartRemoteDCmd : public DCmdWithParser {
450
451 // Explicitly list all properties that could be
452 // passed to Agent.startRemoteManagementAgent()
453 // com.sun.management is omitted
454
455 DCmdArgument<char *> _config_file;
456 DCmdArgument<char *> _jmxremote_host;
457 DCmdArgument<char *> _jmxremote_port;
458 DCmdArgument<char *> _jmxremote_rmi_port;
459 DCmdArgument<char *> _jmxremote_ssl;
460 DCmdArgument<char *> _jmxremote_registry_ssl;
461 DCmdArgument<char *> _jmxremote_authenticate;
462 DCmdArgument<char *> _jmxremote_password_file;
463 DCmdArgument<char *> _jmxremote_access_file;
464 DCmdArgument<char *> _jmxremote_login_config;
465 DCmdArgument<char *> _jmxremote_ssl_enabled_cipher_suites;
466 DCmdArgument<char *> _jmxremote_ssl_enabled_protocols;
467 DCmdArgument<char *> _jmxremote_ssl_need_client_auth;
468 DCmdArgument<char *> _jmxremote_ssl_config_file;
469
470 // JDP support
471 // Keep autodiscovery char* not bool to pass true/false
472 // as property value to java level.
473 DCmdArgument<char *> _jmxremote_autodiscovery;
474 DCmdArgument<jlong> _jdp_port;
475 DCmdArgument<char *> _jdp_address;
476 DCmdArgument<char *> _jdp_source_addr;
477 DCmdArgument<jlong> _jdp_ttl;
478 DCmdArgument<jlong> _jdp_pause;
479 DCmdArgument<char *> _jdp_name;
480
481 public:
482 static int num_arguments() { return 21; }
483
484 JMXStartRemoteDCmd(outputStream *output, bool heap_allocated);
485
486 static const char *name() {
487 return "ManagementAgent.start";
488 }
489
490 static const char *description() {
491 return "Start remote management agent.";
492 }
493
494 virtual void execute(DCmdSource source, TRAPS);
495 };
496
497 class JMXStartLocalDCmd : public DCmd {
498
499 // Explicitly request start of local agent,
500 // it will not be started by start dcmd
501
502
503 public:
504 JMXStartLocalDCmd(outputStream *output, bool heap_allocated);
505
506 static const char *name() {
507 return "ManagementAgent.start_local";
508 }
509
510 static const char *description() {
511 return "Start local management agent.";
512 }
513
514 virtual void execute(DCmdSource source, TRAPS);
515
516 };
517
518 class JMXStopRemoteDCmd : public DCmd {
519 public:
520 JMXStopRemoteDCmd(outputStream *output, bool heap_allocated) :
521 DCmd(output, heap_allocated) {
522 // Do Nothing
523 }
524
525 static const char *name() {
526 return "ManagementAgent.stop";
527 }
528
529 static const char *description() {
530 return "Stop remote management agent.";
531 }
532
533 virtual void execute(DCmdSource source, TRAPS);
534 };
535
536 // Print the JMX system status
537 class JMXStatusDCmd : public DCmd {
538 public:
539 JMXStatusDCmd(outputStream *output, bool heap_allocated);
540
541 static const char *name() {
542 return "ManagementAgent.status";
543 }
544
545 static const char *description() {
546 return "Print the management agent status.";
547 }
548
549 static const JavaPermission permission() {
550 JavaPermission p = {"java.lang.management.ManagementPermission",
551 "monitor", nullptr};
552 return p;
553 }
554
555 virtual void execute(DCmdSource source, TRAPS);
556
557 };
558
559 class CompileQueueDCmd : public DCmd {
560 public:
561 CompileQueueDCmd(outputStream* output, bool heap) : DCmd(output, heap) {}
562 static const char* name() {
563 return "Compiler.queue";
564 }
565 static const char* description() {
566 return "Print methods queued for compilation.";
567 }
568 static const char* impact() {
569 return "Low";
570 }
571 static const JavaPermission permission() {
572 JavaPermission p = {"java.lang.management.ManagementPermission",
573 "monitor", nullptr};
574 return p;
575 }
576 virtual void execute(DCmdSource source, TRAPS);
577 };
578
579 #ifdef LINUX
580 class PerfMapDCmd : public DCmd {
581 public:
582 PerfMapDCmd(outputStream* output, bool heap) : DCmd(output, heap) {}
583 static const char* name() {
584 return "Compiler.perfmap";
585 }
586 static const char* description() {
587 return "Write map file for Linux perf tool.";
588 }
589 static const char* impact() {
590 return "Low";
591 }
592 static const JavaPermission permission() {
593 JavaPermission p = {"java.lang.management.ManagementPermission",
594 "monitor", nullptr};
595 return p;
596 }
597 virtual void execute(DCmdSource source, TRAPS);
598 };
599 #endif // LINUX
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", nullptr};
616 return p;
617 }
618 virtual void execute(DCmdSource source, TRAPS);
619 };
620
621 class CodeCacheDCmd : public DCmd {
622 public:
623 CodeCacheDCmd(outputStream* output, bool heap) : DCmd(output, heap) {}
624 static const char* name() {
625 return "Compiler.codecache";
626 }
627 static const char* description() {
628 return "Print code cache layout and bounds.";
629 }
630 static const char* impact() {
631 return "Low";
632 }
633 static const JavaPermission permission() {
634 JavaPermission p = {"java.lang.management.ManagementPermission",
635 "monitor", nullptr};
636 return p;
637 }
638 virtual void execute(DCmdSource source, TRAPS);
639 };
640
641 //---< BEGIN >--- CodeHeap State Analytics.
642 class CodeHeapAnalyticsDCmd : public DCmdWithParser {
643 protected:
644 DCmdArgument<char*> _function;
645 DCmdArgument<jlong> _granularity;
646 public:
647 static int num_arguments() { return 2; }
648 CodeHeapAnalyticsDCmd(outputStream* output, bool heap);
649 static const char* name() {
650 return "Compiler.CodeHeap_Analytics";
651 }
652 static const char* description() {
653 return "Print CodeHeap analytics";
654 }
655 static const char* impact() {
656 return "Low: Depends on code heap size and content. "
657 "Holds CodeCache_lock during analysis step, usually sub-second duration.";
658 }
659 static const JavaPermission permission() {
660 JavaPermission p = {"java.lang.management.ManagementPermission",
661 "monitor", nullptr};
662 return p;
663 }
664 virtual void execute(DCmdSource source, TRAPS);
665 };
666 //---< END >--- CodeHeap State Analytics.
667
668 class CompilerDirectivesPrintDCmd : public DCmd {
669 public:
670 CompilerDirectivesPrintDCmd(outputStream* output, bool heap) : DCmd(output, heap) {}
671 static const char* name() {
672 return "Compiler.directives_print";
673 }
674 static const char* description() {
675 return "Print all active compiler directives.";
676 }
677 static const char* impact() {
678 return "Low";
679 }
680 static const JavaPermission permission() {
681 JavaPermission p = {"java.lang.management.ManagementPermission",
682 "monitor", nullptr};
683 return p;
684 }
685 virtual void execute(DCmdSource source, TRAPS);
686 };
687
688 class CompilerDirectivesRemoveDCmd : public DCmd {
689 public:
690 CompilerDirectivesRemoveDCmd(outputStream* output, bool heap) : DCmd(output, heap) {}
691 static const char* name() {
692 return "Compiler.directives_remove";
693 }
694 static const char* description() {
695 return "Remove latest added compiler directive.";
696 }
697 static const char* impact() {
698 return "Low";
699 }
700 static const JavaPermission permission() {
701 JavaPermission p = {"java.lang.management.ManagementPermission",
702 "control", nullptr};
703 return p;
704 }
705 virtual void execute(DCmdSource source, TRAPS);
706 };
707
708 class CompilerDirectivesAddDCmd : public DCmdWithParser {
709 protected:
710 DCmdArgument<char*> _filename;
711 public:
712 static int num_arguments() { return 1; }
713 CompilerDirectivesAddDCmd(outputStream* output, bool heap);
714 static const char* name() {
715 return "Compiler.directives_add";
716 }
717 static const char* description() {
718 return "Add compiler directives from file.";
719 }
720 static const char* impact() {
721 return "Low";
722 }
723 static const JavaPermission permission() {
724 JavaPermission p = {"java.lang.management.ManagementPermission",
725 "control", nullptr};
726 return p;
727 }
728 virtual void execute(DCmdSource source, TRAPS);
729 };
730
731 class CompilerDirectivesClearDCmd : public DCmd {
732 public:
733 CompilerDirectivesClearDCmd(outputStream* output, bool heap) : DCmd(output, heap) {}
734 static const char* name() {
735 return "Compiler.directives_clear";
736 }
737 static const char* description() {
738 return "Remove all compiler directives.";
739 }
740 static const char* impact() {
741 return "Low";
742 }
743 static const JavaPermission permission() {
744 JavaPermission p = {"java.lang.management.ManagementPermission",
745 "control", nullptr};
746 return p;
747 }
748 virtual void execute(DCmdSource source, TRAPS);
749 };
750
751 ///////////////////////////////////////////////////////////////////////
752 //
753 // jcmd command support for symbol table, string table and system dictionary dumping:
754 // VM.symboltable -verbose: for dumping the symbol table
755 // VM.stringtable -verbose: for dumping the string table
756 // VM.systemdictionary -verbose: for dumping the system dictionary table
757 //
758 class VM_DumpHashtable : public VM_Operation {
759 private:
760 outputStream* _out;
761 int _which;
762 bool _verbose;
763 public:
764 enum {
765 DumpSymbols = 1 << 0,
766 DumpStrings = 1 << 1,
767 DumpSysDict = 1 << 2 // not implemented yet
768 };
769 VM_DumpHashtable(outputStream* out, int which, bool verbose) {
770 _out = out;
771 _which = which;
772 _verbose = verbose;
773 }
774
775 virtual VMOp_Type type() const { return VMOp_DumpHashtable; }
776
777 virtual void doit() {
778 switch (_which) {
779 case DumpSymbols:
780 SymbolTable::dump(_out, _verbose);
781 break;
782 case DumpStrings:
783 StringTable::dump(_out, _verbose);
784 break;
785 case DumpSysDict:
786 SystemDictionary::dump(_out, _verbose);
787 break;
788 default:
789 ShouldNotReachHere();
790 }
791 }
792 };
793
794 class SymboltableDCmd : public DCmdWithParser {
795 protected:
796 DCmdArgument<bool> _verbose;
797 public:
798 static int num_arguments() { return 1; }
799 SymboltableDCmd(outputStream* output, bool heap);
800 static const char* name() {
801 return "VM.symboltable";
802 }
803 static const char* description() {
804 return "Dump symbol table.";
805 }
806 static const char* impact() {
807 return "Medium: Depends on Java content.";
808 }
809 static const JavaPermission permission() {
810 JavaPermission p = {"java.lang.management.ManagementPermission",
811 "monitor", nullptr};
812 return p;
813 }
814 virtual void execute(DCmdSource source, TRAPS);
815 };
816
817 class StringtableDCmd : public DCmdWithParser {
818 protected:
819 DCmdArgument<bool> _verbose;
820 public:
821 static int num_arguments() { return 1; }
822 StringtableDCmd(outputStream* output, bool heap);
823 static const char* name() {
824 return "VM.stringtable";
825 }
826 static const char* description() {
827 return "Dump string table.";
828 }
829 static const char* impact() {
830 return "Medium: Depends on Java content.";
831 }
832 static const JavaPermission permission() {
833 JavaPermission p = {"java.lang.management.ManagementPermission",
834 "monitor", nullptr};
835 return p;
836 }
837 virtual void execute(DCmdSource source, TRAPS);
838 };
839
840 class SystemDictionaryDCmd : public DCmdWithParser {
841 protected:
842 DCmdArgument<bool> _verbose;
843 public:
844 static int num_arguments() { return 1; }
845 SystemDictionaryDCmd(outputStream* output, bool heap);
846 static const char* name() {
847 return "VM.systemdictionary";
848 }
849 static const char* description() {
850 return "Prints the statistics for dictionary hashtable sizes and bucket length";
851 }
852 static const char* impact() {
853 return "Medium: Depends on Java content.";
854 }
855 static const JavaPermission permission() {
856 JavaPermission p = {"java.lang.management.ManagementPermission",
857 "monitor", nullptr};
858 return p;
859 }
860 virtual void execute(DCmdSource source, TRAPS);
861 };
862
863 class ClassesDCmd : public DCmdWithParser {
864 protected:
865 DCmdArgument<bool> _verbose;
866 public:
867 static int num_arguments() { return 1; }
868 ClassesDCmd(outputStream* output, bool heap);
869 static const char* name() {
870 return "VM.classes";
871 }
872 static const char* description() {
873 return "Print all loaded classes";
874 }
875 static const char* impact() {
876 return "Medium: Depends on number of loaded classes.";
877 }
878 static const JavaPermission permission() {
879 JavaPermission p = {"java.lang.management.ManagementPermission",
880 "monitor", nullptr};
881 return p;
882 }
883 virtual void execute(DCmdSource source, TRAPS);
884 };
885
886 #if INCLUDE_JVMTI
887 class DebugOnCmdStartDCmd : public DCmd {
888 public:
889 DebugOnCmdStartDCmd(outputStream* output, bool heap) : DCmd(output, heap) {}
890 static const char* name() {
891 return "VM.start_java_debugging";
892 }
893 static const char* description() {
894 return "Starts up the Java debugging if the jdwp agentlib was enabled with the option onjcmd=y.";
895 }
896 static const char* impact() {
897 return "High: Switches the VM into Java debug mode.";
898 }
899 static const JavaPermission permission() {
900 JavaPermission p = { "java.lang.management.ManagementPermission", "control", nullptr };
901 return p;
902 }
903 virtual void execute(DCmdSource source, TRAPS);
904 };
905 #endif // INCLUDE_JVMTI
906
907 class EventLogDCmd : public DCmdWithParser {
908 protected:
909 DCmdArgument<char*> _log;
910 DCmdArgument<char*> _max;
911 public:
912 static int num_arguments() { return 2; }
913 EventLogDCmd(outputStream* output, bool heap);
914 static const char* name() {
915 return "VM.events";
916 }
917 static const char* description() {
918 return "Print VM event logs";
919 }
920 static const char* impact() {
921 return "Low: Depends on event log size. ";
922 }
923 static const JavaPermission permission() {
924 JavaPermission p = {"java.lang.management.ManagementPermission",
925 "monitor", nullptr};
926 return p;
927 }
928 virtual void execute(DCmdSource source, TRAPS);
929 };
930
931 class ThreadDumpToFileDCmd : public DCmdWithParser {
932 private:
933 void dumpToFile(Symbol* name, Symbol* signature, const char* path, bool overwrite, TRAPS);
934 protected:
935 DCmdArgument<bool> _overwrite;
936 DCmdArgument<char*> _format;
937 DCmdArgument<char*> _filepath;
938 public:
939 static int num_arguments() { return 3; }
940 ThreadDumpToFileDCmd(outputStream *output, bool heap);
941 static const char *name() {
942 return "Thread.dump_to_file";
943 }
944 static const char *description() {
945 return "Dump threads, with stack traces, to a file in plain text or JSON format.";
946 }
947 static const char* impact() {
948 return "Medium: Depends on the number of threads.";
949 }
950 static const JavaPermission permission() {
951 JavaPermission p = {"java.lang.management.ManagementPermission", "monitor", nullptr};
952 return p;
953 }
954 virtual void execute(DCmdSource source, TRAPS);
955 };
956
957 class CompilationMemoryStatisticDCmd: public DCmdWithParser {
958 protected:
959 DCmdArgument<bool> _human_readable;
960 DCmdArgument<MemorySizeArgument> _minsize;
961 public:
962 static int num_arguments() { return 2; }
963 CompilationMemoryStatisticDCmd(outputStream* output, bool heap);
964 static const char* name() {
965 return "Compiler.memory";
966 }
967 static const char* description() {
968 return "Print compilation footprint";
969 }
970 static const char* impact() {
971 return "Medium: Pause time depends on number of compiled methods";
972 }
973 static const JavaPermission permission() {
974 JavaPermission p = {"java.lang.management.ManagementPermission",
975 "monitor", nullptr};
976 return p;
977 }
978 virtual void execute(DCmdSource source, TRAPS);
979 };
980
981 #ifdef LINUX
982
983 class SystemMapDCmd : public DCmdWithParser {
984 DCmdArgument<bool> _human_readable;
985 public:
986 static int num_arguments() { return 1; }
987 SystemMapDCmd(outputStream* output, bool heap);
988 static const char* name() { return "System.map"; }
989 static const char* description() {
990 return "Prints an annotated process memory map of the VM process (linux only).";
991 }
992 static const char* impact() { return "Low"; }
993 static const JavaPermission permission() {
994 JavaPermission p = {"java.lang.management.ManagementPermission",
995 "control", nullptr};
996 return p;
997 }
998 virtual void execute(DCmdSource source, TRAPS);
999 };
1000
1001 class SystemDumpMapDCmd : public DCmdWithParser {
1002 DCmdArgument<bool> _human_readable;
1003 DCmdArgument<char*> _filename;
1004 public:
1005 static int num_arguments() { return 2; }
1006 SystemDumpMapDCmd(outputStream* output, bool heap);
1007 static const char* name() { return "System.dump_map"; }
1008 static const char* description() {
1009 return "Dumps an annotated process memory map to an output file (linux only).";
1010 }
1011 static const char* impact() { return "Low"; }
1012 static const JavaPermission permission() {
1013 JavaPermission p = {"java.lang.management.ManagementPermission",
1014 "control", nullptr};
1015 return p;
1016 }
1017 virtual void execute(DCmdSource source, TRAPS);
1018 };
1019
1020 #endif // LINUX
1021
1022 #endif // SHARE_SERVICES_DIAGNOSTICCOMMAND_HPP