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