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