1 /*
2 * Copyright (c) 2011, 2024, 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 AOTEndTrainingDCmd : public DCmd {
400 public:
401 AOTEndTrainingDCmd(outputStream* output, bool heap) : DCmd(output, heap) { }
402 static const char* name() { return "AOT.end_training"; }
403 static const char* description() {
404 return "End AOT training and create the cache.";
405 }
406 static const char* impact() {
407 return "Medium: Pause time depends on number of loaded classes";
408 }
409 static const JavaPermission permission() {
410 JavaPermission p = {"java.lang.management.ManagementPermission",
411 "monitor", nullptr};
412 return p;
413 }
414 virtual void execute(DCmdSource source, TRAPS);
415 };
416 #endif // INCLUDE_CDS
417
418 #if INCLUDE_CDS
419 class DumpSharedArchiveDCmd: public DCmdWithParser {
420 protected:
421 DCmdArgument<char*> _suboption; // option of VM.cds
422 DCmdArgument<char*> _filename; // file name, optional
423 public:
424 static int num_arguments() { return 2; }
425 DumpSharedArchiveDCmd(outputStream* output, bool heap);
426 static const char* name() {
427 return "VM.cds";
428 }
429 static const char* description() {
430 return "Dump a static or dynamic shared archive including all shareable classes";
431 }
432 static const char* impact() {
433 return "Medium: Pause time depends on number of loaded classes";
434 }
435 static const JavaPermission permission() {
436 JavaPermission p = {"java.lang.management.ManagementPermission",
437 "monitor", nullptr};
438 return p;
439 }
440 virtual void execute(DCmdSource source, TRAPS);
441 };
442 #endif // INCLUDE_CDS
443
444 // See also: thread_dump in attachListener.cpp
445 class ThreadDumpDCmd : public DCmdWithParser {
446 protected:
447 DCmdArgument<bool> _locks;
448 DCmdArgument<bool> _extended;
449 public:
450 static int num_arguments() { return 2; }
451 ThreadDumpDCmd(outputStream* output, bool heap);
452 static const char* name() { return "Thread.print"; }
453 static const char* description() {
454 return "Print all threads with stacktraces.";
455 }
456 static const char* impact() {
457 return "Medium: Depends on the number of threads.";
458 }
459 static const JavaPermission permission() {
460 JavaPermission p = {"java.lang.management.ManagementPermission",
461 "monitor", nullptr};
462 return p;
463 }
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 static int num_arguments() { return 21; }
503
504 JMXStartRemoteDCmd(outputStream *output, bool heap_allocated);
505
506 static const char *name() {
507 return "ManagementAgent.start";
508 }
509
510 static const char *description() {
511 return "Start remote management agent.";
512 }
513
514 virtual void execute(DCmdSource source, TRAPS);
515 };
516
517 class JMXStartLocalDCmd : public DCmd {
518
519 // Explicitly request start of local agent,
520 // it will not be started by start dcmd
521
522
523 public:
524 JMXStartLocalDCmd(outputStream *output, bool heap_allocated);
525
526 static const char *name() {
527 return "ManagementAgent.start_local";
528 }
529
530 static const char *description() {
531 return "Start local management agent.";
532 }
533
534 virtual void execute(DCmdSource source, TRAPS);
535
536 };
537
538 class JMXStopRemoteDCmd : public DCmd {
539 public:
540 JMXStopRemoteDCmd(outputStream *output, bool heap_allocated) :
541 DCmd(output, heap_allocated) {
542 // Do Nothing
543 }
544
545 static const char *name() {
546 return "ManagementAgent.stop";
547 }
548
549 static const char *description() {
550 return "Stop remote management agent.";
551 }
552
553 virtual void execute(DCmdSource source, TRAPS);
554 };
555
556 // Print the JMX system status
557 class JMXStatusDCmd : public DCmd {
558 public:
559 JMXStatusDCmd(outputStream *output, bool heap_allocated);
560
561 static const char *name() {
562 return "ManagementAgent.status";
563 }
564
565 static const char *description() {
566 return "Print the management agent status.";
567 }
568
569 static const JavaPermission permission() {
570 JavaPermission p = {"java.lang.management.ManagementPermission",
571 "monitor", nullptr};
572 return p;
573 }
574
575 virtual void execute(DCmdSource source, TRAPS);
576
577 };
578
579 class CompileQueueDCmd : public DCmd {
580 public:
581 CompileQueueDCmd(outputStream* output, bool heap) : DCmd(output, heap) {}
582 static const char* name() {
583 return "Compiler.queue";
584 }
585 static const char* description() {
586 return "Print methods queued for compilation.";
587 }
588 static const char* impact() {
589 return "Low";
590 }
591 static const JavaPermission permission() {
592 JavaPermission p = {"java.lang.management.ManagementPermission",
593 "monitor", nullptr};
594 return p;
595 }
596 virtual void execute(DCmdSource source, TRAPS);
597 };
598
599 #ifdef LINUX
600 class PerfMapDCmd : public DCmdWithParser {
601 protected:
602 DCmdArgument<char*> _filename;
603 public:
604 static int num_arguments() { return 1; }
605 PerfMapDCmd(outputStream* output, bool heap);
606 static const char* name() {
607 return "Compiler.perfmap";
608 }
609 static const char* description() {
610 return "Write map file for Linux perf tool.";
611 }
612 static const char* impact() {
613 return "Low";
614 }
615 static const JavaPermission permission() {
616 JavaPermission p = {"java.lang.management.ManagementPermission",
617 "monitor", nullptr};
618 return p;
619 }
620 virtual void execute(DCmdSource source, TRAPS);
621 };
622 #endif // LINUX
623
624 class CodeListDCmd : public DCmd {
625 public:
626 CodeListDCmd(outputStream* output, bool heap) : DCmd(output, heap) {}
627 static const char* name() {
628 return "Compiler.codelist";
629 }
630 static const char* description() {
631 return "Print all compiled methods in code cache that are alive";
632 }
633 static const char* impact() {
634 return "Medium";
635 }
636 static const JavaPermission permission() {
637 JavaPermission p = {"java.lang.management.ManagementPermission",
638 "monitor", nullptr};
639 return p;
640 }
641 virtual void execute(DCmdSource source, TRAPS);
642 };
643
644 class CodeCacheDCmd : public DCmd {
645 public:
646 CodeCacheDCmd(outputStream* output, bool heap) : DCmd(output, heap) {}
647 static const char* name() {
648 return "Compiler.codecache";
649 }
650 static const char* description() {
651 return "Print code cache layout and bounds.";
652 }
653 static const char* impact() {
654 return "Low";
655 }
656 static const JavaPermission permission() {
657 JavaPermission p = {"java.lang.management.ManagementPermission",
658 "monitor", nullptr};
659 return p;
660 }
661 virtual void execute(DCmdSource source, TRAPS);
662 };
663
664 //---< BEGIN >--- CodeHeap State Analytics.
665 class CodeHeapAnalyticsDCmd : public DCmdWithParser {
666 protected:
667 DCmdArgument<char*> _function;
668 DCmdArgument<jlong> _granularity;
669 public:
670 static int num_arguments() { return 2; }
671 CodeHeapAnalyticsDCmd(outputStream* output, bool heap);
672 static const char* name() {
673 return "Compiler.CodeHeap_Analytics";
674 }
675 static const char* description() {
676 return "Print CodeHeap analytics";
677 }
678 static const char* impact() {
679 return "Low: Depends on code heap size and content. "
680 "Holds CodeCache_lock during analysis step, usually sub-second duration.";
681 }
682 static const JavaPermission permission() {
683 JavaPermission p = {"java.lang.management.ManagementPermission",
684 "monitor", nullptr};
685 return p;
686 }
687 virtual void execute(DCmdSource source, TRAPS);
688 };
689 //---< END >--- CodeHeap State Analytics.
690
691 class CompilerDirectivesPrintDCmd : public DCmd {
692 public:
693 CompilerDirectivesPrintDCmd(outputStream* output, bool heap) : DCmd(output, heap) {}
694 static const char* name() {
695 return "Compiler.directives_print";
696 }
697 static const char* description() {
698 return "Print all active compiler directives.";
699 }
700 static const char* impact() {
701 return "Low";
702 }
703 static const JavaPermission permission() {
704 JavaPermission p = {"java.lang.management.ManagementPermission",
705 "monitor", nullptr};
706 return p;
707 }
708 virtual void execute(DCmdSource source, TRAPS);
709 };
710
711 class CompilerDirectivesRemoveDCmd : public DCmd {
712 public:
713 CompilerDirectivesRemoveDCmd(outputStream* output, bool heap) : DCmd(output, heap) {}
714 static const char* name() {
715 return "Compiler.directives_remove";
716 }
717 static const char* description() {
718 return "Remove latest added compiler directive.";
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 CompilerDirectivesAddDCmd : public DCmdWithParser {
732 protected:
733 DCmdArgument<char*> _filename;
734 public:
735 static int num_arguments() { return 1; }
736 CompilerDirectivesAddDCmd(outputStream* output, bool heap);
737 static const char* name() {
738 return "Compiler.directives_add";
739 }
740 static const char* description() {
741 return "Add compiler directives from file.";
742 }
743 static const char* impact() {
744 return "Low";
745 }
746 static const JavaPermission permission() {
747 JavaPermission p = {"java.lang.management.ManagementPermission",
748 "control", nullptr};
749 return p;
750 }
751 virtual void execute(DCmdSource source, TRAPS);
752 };
753
754 class CompilerDirectivesClearDCmd : public DCmd {
755 public:
756 CompilerDirectivesClearDCmd(outputStream* output, bool heap) : DCmd(output, heap) {}
757 static const char* name() {
758 return "Compiler.directives_clear";
759 }
760 static const char* description() {
761 return "Remove all compiler directives.";
762 }
763 static const char* impact() {
764 return "Low";
765 }
766 static const JavaPermission permission() {
767 JavaPermission p = {"java.lang.management.ManagementPermission",
768 "control", nullptr};
769 return p;
770 }
771 virtual void execute(DCmdSource source, TRAPS);
772 };
773
774 ///////////////////////////////////////////////////////////////////////
775 //
776 // jcmd command support for symbol table, string table and system dictionary dumping:
777 // VM.symboltable -verbose: for dumping the symbol table
778 // VM.stringtable -verbose: for dumping the string table
779 // VM.systemdictionary -verbose: for dumping the system dictionary table
780 //
781 class VM_DumpHashtable : public VM_Operation {
782 private:
783 outputStream* _out;
784 int _which;
785 bool _verbose;
786 public:
787 enum {
788 DumpSymbols = 1 << 0,
789 DumpStrings = 1 << 1,
790 DumpSysDict = 1 << 2 // not implemented yet
791 };
792 VM_DumpHashtable(outputStream* out, int which, bool verbose) {
793 _out = out;
794 _which = which;
795 _verbose = verbose;
796 }
797
798 virtual VMOp_Type type() const { return VMOp_DumpHashtable; }
799
800 virtual void doit() {
801 switch (_which) {
802 case DumpSymbols:
803 SymbolTable::dump(_out, _verbose);
804 break;
805 case DumpStrings:
806 StringTable::dump(_out, _verbose);
807 break;
808 case DumpSysDict:
809 SystemDictionary::dump(_out, _verbose);
810 break;
811 default:
812 ShouldNotReachHere();
813 }
814 }
815 };
816
817 class SymboltableDCmd : public DCmdWithParser {
818 protected:
819 DCmdArgument<bool> _verbose;
820 public:
821 static int num_arguments() { return 1; }
822 SymboltableDCmd(outputStream* output, bool heap);
823 static const char* name() {
824 return "VM.symboltable";
825 }
826 static const char* description() {
827 return "Dump symbol 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 StringtableDCmd : public DCmdWithParser {
841 protected:
842 DCmdArgument<bool> _verbose;
843 public:
844 static int num_arguments() { return 1; }
845 StringtableDCmd(outputStream* output, bool heap);
846 static const char* name() {
847 return "VM.stringtable";
848 }
849 static const char* description() {
850 return "Dump string table.";
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 SystemDictionaryDCmd : public DCmdWithParser {
864 protected:
865 DCmdArgument<bool> _verbose;
866 public:
867 static int num_arguments() { return 1; }
868 SystemDictionaryDCmd(outputStream* output, bool heap);
869 static const char* name() {
870 return "VM.systemdictionary";
871 }
872 static const char* description() {
873 return "Prints the statistics for dictionary hashtable sizes and bucket length";
874 }
875 static const char* impact() {
876 return "Medium: Depends on Java content.";
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 class ClassesDCmd : public DCmdWithParser {
887 protected:
888 DCmdArgument<bool> _verbose;
889 public:
890 static int num_arguments() { return 1; }
891 ClassesDCmd(outputStream* output, bool heap);
892 static const char* name() {
893 return "VM.classes";
894 }
895 static const char* description() {
896 return "Print all loaded classes";
897 }
898 static const char* impact() {
899 return "Medium: Depends on number of loaded classes.";
900 }
901 static const JavaPermission permission() {
902 JavaPermission p = {"java.lang.management.ManagementPermission",
903 "monitor", nullptr};
904 return p;
905 }
906 virtual void execute(DCmdSource source, TRAPS);
907 };
908
909 class EventLogDCmd : public DCmdWithParser {
910 protected:
911 DCmdArgument<char*> _log;
912 DCmdArgument<char*> _max;
913 public:
914 static int num_arguments() { return 2; }
915 EventLogDCmd(outputStream* output, bool heap);
916 static const char* name() {
917 return "VM.events";
918 }
919 static const char* description() {
920 return "Print VM event logs";
921 }
922 static const char* impact() {
923 return "Low: Depends on event log size. ";
924 }
925 static const JavaPermission permission() {
926 JavaPermission p = {"java.lang.management.ManagementPermission",
927 "monitor", nullptr};
928 return p;
929 }
930 virtual void execute(DCmdSource source, TRAPS);
931 };
932
933 class ThreadDumpToFileDCmd : public DCmdWithParser {
934 private:
935 void dumpToFile(Symbol* name, Symbol* signature, const char* path, bool overwrite, TRAPS);
936 protected:
937 DCmdArgument<bool> _overwrite;
938 DCmdArgument<char*> _format;
939 DCmdArgument<char*> _filepath;
940 public:
941 static int num_arguments() { return 3; }
942 ThreadDumpToFileDCmd(outputStream *output, bool heap);
943 static const char *name() {
944 return "Thread.dump_to_file";
945 }
946 static const char *description() {
947 return "Dump threads, with stack traces, to a file in plain text or JSON format.";
948 }
949 static const char* impact() {
950 return "Medium: Depends on the number of threads.";
951 }
952 static const JavaPermission permission() {
953 JavaPermission p = {"java.lang.management.ManagementPermission", "monitor", nullptr};
954 return p;
955 }
956 virtual void execute(DCmdSource source, TRAPS);
957 };
958
959 class CompilationMemoryStatisticDCmd: public DCmdWithParser {
960 protected:
961 DCmdArgument<bool> _human_readable;
962 DCmdArgument<MemorySizeArgument> _minsize;
963 public:
964 static int num_arguments() { return 2; }
965 CompilationMemoryStatisticDCmd(outputStream* output, bool heap);
966 static const char* name() {
967 return "Compiler.memory";
968 }
969 static const char* description() {
970 return "Print compilation footprint";
971 }
972 static const char* impact() {
973 return "Medium: Pause time depends on number of compiled methods";
974 }
975 static const JavaPermission permission() {
976 JavaPermission p = {"java.lang.management.ManagementPermission",
977 "monitor", nullptr};
978 return p;
979 }
980 virtual void execute(DCmdSource source, TRAPS);
981 };
982
983 #if defined(LINUX) || defined(_WIN64)
984
985 class SystemMapDCmd : public DCmd {
986 public:
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 and Windows only).";
991 }
992 static const char* impact() { return "Medium; can be high for very large java heaps."; }
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<char*> _filename;
1003 public:
1004 static int num_arguments() { return 1; }
1005 SystemDumpMapDCmd(outputStream* output, bool heap);
1006 static const char* name() { return "System.dump_map"; }
1007 static const char* description() {
1008 return "Dumps an annotated process memory map to an output file (linux and Windows only).";
1009 }
1010 static const char* impact() { return "Medium; can be high for very large java heaps."; }
1011 static const JavaPermission permission() {
1012 JavaPermission p = {"java.lang.management.ManagementPermission",
1013 "control", nullptr};
1014 return p;
1015 }
1016 virtual void execute(DCmdSource source, TRAPS);
1017 };
1018
1019 #endif // LINUX or WINDOWS
1020
1021 #endif // SHARE_SERVICES_DIAGNOSTICCOMMAND_HPP