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 DCmdWithParser { 581 protected: 582 DCmdArgument<char*> _filename; 583 public: 584 static int num_arguments() { return 1; } 585 PerfMapDCmd(outputStream* output, bool heap); 586 static const char* name() { 587 return "Compiler.perfmap"; 588 } 589 static const char* description() { 590 return "Write map file for Linux perf tool."; 591 } 592 static const char* impact() { 593 return "Low"; 594 } 595 static const JavaPermission permission() { 596 JavaPermission p = {"java.lang.management.ManagementPermission", 597 "monitor", nullptr}; 598 return p; 599 } 600 virtual void execute(DCmdSource source, TRAPS); 601 }; 602 #endif // LINUX 603 604 class CodeListDCmd : public DCmd { 605 public: 606 CodeListDCmd(outputStream* output, bool heap) : DCmd(output, heap) {} 607 static const char* name() { 608 return "Compiler.codelist"; 609 } 610 static const char* description() { 611 return "Print all compiled methods in code cache that are alive"; 612 } 613 static const char* impact() { 614 return "Medium"; 615 } 616 static const JavaPermission permission() { 617 JavaPermission p = {"java.lang.management.ManagementPermission", 618 "monitor", nullptr}; 619 return p; 620 } 621 virtual void execute(DCmdSource source, TRAPS); 622 }; 623 624 class CodeCacheDCmd : public DCmd { 625 public: 626 CodeCacheDCmd(outputStream* output, bool heap) : DCmd(output, heap) {} 627 static const char* name() { 628 return "Compiler.codecache"; 629 } 630 static const char* description() { 631 return "Print code cache layout and bounds."; 632 } 633 static const char* impact() { 634 return "Low"; 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 //---< BEGIN >--- CodeHeap State Analytics. 645 class CodeHeapAnalyticsDCmd : public DCmdWithParser { 646 protected: 647 DCmdArgument<char*> _function; 648 DCmdArgument<jlong> _granularity; 649 public: 650 static int num_arguments() { return 2; } 651 CodeHeapAnalyticsDCmd(outputStream* output, bool heap); 652 static const char* name() { 653 return "Compiler.CodeHeap_Analytics"; 654 } 655 static const char* description() { 656 return "Print CodeHeap analytics"; 657 } 658 static const char* impact() { 659 return "Low: Depends on code heap size and content. " 660 "Holds CodeCache_lock during analysis step, usually sub-second duration."; 661 } 662 static const JavaPermission permission() { 663 JavaPermission p = {"java.lang.management.ManagementPermission", 664 "monitor", nullptr}; 665 return p; 666 } 667 virtual void execute(DCmdSource source, TRAPS); 668 }; 669 //---< END >--- CodeHeap State Analytics. 670 671 class CompilerDirectivesPrintDCmd : public DCmd { 672 public: 673 CompilerDirectivesPrintDCmd(outputStream* output, bool heap) : DCmd(output, heap) {} 674 static const char* name() { 675 return "Compiler.directives_print"; 676 } 677 static const char* description() { 678 return "Print all active compiler directives."; 679 } 680 static const char* impact() { 681 return "Low"; 682 } 683 static const JavaPermission permission() { 684 JavaPermission p = {"java.lang.management.ManagementPermission", 685 "monitor", nullptr}; 686 return p; 687 } 688 virtual void execute(DCmdSource source, TRAPS); 689 }; 690 691 class CompilerDirectivesRemoveDCmd : public DCmd { 692 public: 693 CompilerDirectivesRemoveDCmd(outputStream* output, bool heap) : DCmd(output, heap) {} 694 static const char* name() { 695 return "Compiler.directives_remove"; 696 } 697 static const char* description() { 698 return "Remove latest added compiler directive."; 699 } 700 static const char* impact() { 701 return "Low"; 702 } 703 static const JavaPermission permission() { 704 JavaPermission p = {"java.lang.management.ManagementPermission", 705 "control", nullptr}; 706 return p; 707 } 708 virtual void execute(DCmdSource source, TRAPS); 709 }; 710 711 class CompilerDirectivesAddDCmd : public DCmdWithParser { 712 protected: 713 DCmdArgument<char*> _filename; 714 public: 715 static int num_arguments() { return 1; } 716 CompilerDirectivesAddDCmd(outputStream* output, bool heap); 717 static const char* name() { 718 return "Compiler.directives_add"; 719 } 720 static const char* description() { 721 return "Add compiler directives from file."; 722 } 723 static const char* impact() { 724 return "Low"; 725 } 726 static const JavaPermission permission() { 727 JavaPermission p = {"java.lang.management.ManagementPermission", 728 "control", nullptr}; 729 return p; 730 } 731 virtual void execute(DCmdSource source, TRAPS); 732 }; 733 734 class CompilerDirectivesClearDCmd : public DCmd { 735 public: 736 CompilerDirectivesClearDCmd(outputStream* output, bool heap) : DCmd(output, heap) {} 737 static const char* name() { 738 return "Compiler.directives_clear"; 739 } 740 static const char* description() { 741 return "Remove all compiler directives."; 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 /////////////////////////////////////////////////////////////////////// 755 // 756 // jcmd command support for symbol table, string table and system dictionary dumping: 757 // VM.symboltable -verbose: for dumping the symbol table 758 // VM.stringtable -verbose: for dumping the string table 759 // VM.systemdictionary -verbose: for dumping the system dictionary table 760 // 761 class VM_DumpHashtable : public VM_Operation { 762 private: 763 outputStream* _out; 764 int _which; 765 bool _verbose; 766 public: 767 enum { 768 DumpSymbols = 1 << 0, 769 DumpStrings = 1 << 1, 770 DumpSysDict = 1 << 2 // not implemented yet 771 }; 772 VM_DumpHashtable(outputStream* out, int which, bool verbose) { 773 _out = out; 774 _which = which; 775 _verbose = verbose; 776 } 777 778 virtual VMOp_Type type() const { return VMOp_DumpHashtable; } 779 780 virtual void doit() { 781 switch (_which) { 782 case DumpSymbols: 783 SymbolTable::dump(_out, _verbose); 784 break; 785 case DumpStrings: 786 StringTable::dump(_out, _verbose); 787 break; 788 case DumpSysDict: 789 SystemDictionary::dump(_out, _verbose); 790 break; 791 default: 792 ShouldNotReachHere(); 793 } 794 } 795 }; 796 797 class SymboltableDCmd : public DCmdWithParser { 798 protected: 799 DCmdArgument<bool> _verbose; 800 public: 801 static int num_arguments() { return 1; } 802 SymboltableDCmd(outputStream* output, bool heap); 803 static const char* name() { 804 return "VM.symboltable"; 805 } 806 static const char* description() { 807 return "Dump symbol table."; 808 } 809 static const char* impact() { 810 return "Medium: Depends on Java content."; 811 } 812 static const JavaPermission permission() { 813 JavaPermission p = {"java.lang.management.ManagementPermission", 814 "monitor", nullptr}; 815 return p; 816 } 817 virtual void execute(DCmdSource source, TRAPS); 818 }; 819 820 class StringtableDCmd : public DCmdWithParser { 821 protected: 822 DCmdArgument<bool> _verbose; 823 public: 824 static int num_arguments() { return 1; } 825 StringtableDCmd(outputStream* output, bool heap); 826 static const char* name() { 827 return "VM.stringtable"; 828 } 829 static const char* description() { 830 return "Dump string table."; 831 } 832 static const char* impact() { 833 return "Medium: Depends on Java content."; 834 } 835 static const JavaPermission permission() { 836 JavaPermission p = {"java.lang.management.ManagementPermission", 837 "monitor", nullptr}; 838 return p; 839 } 840 virtual void execute(DCmdSource source, TRAPS); 841 }; 842 843 class SystemDictionaryDCmd : public DCmdWithParser { 844 protected: 845 DCmdArgument<bool> _verbose; 846 public: 847 static int num_arguments() { return 1; } 848 SystemDictionaryDCmd(outputStream* output, bool heap); 849 static const char* name() { 850 return "VM.systemdictionary"; 851 } 852 static const char* description() { 853 return "Prints the statistics for dictionary hashtable sizes and bucket length"; 854 } 855 static const char* impact() { 856 return "Medium: Depends on Java content."; 857 } 858 static const JavaPermission permission() { 859 JavaPermission p = {"java.lang.management.ManagementPermission", 860 "monitor", nullptr}; 861 return p; 862 } 863 virtual void execute(DCmdSource source, TRAPS); 864 }; 865 866 class ClassesDCmd : public DCmdWithParser { 867 protected: 868 DCmdArgument<bool> _verbose; 869 public: 870 static int num_arguments() { return 1; } 871 ClassesDCmd(outputStream* output, bool heap); 872 static const char* name() { 873 return "VM.classes"; 874 } 875 static const char* description() { 876 return "Print all loaded classes"; 877 } 878 static const char* impact() { 879 return "Medium: Depends on number of loaded classes."; 880 } 881 static const JavaPermission permission() { 882 JavaPermission p = {"java.lang.management.ManagementPermission", 883 "monitor", nullptr}; 884 return p; 885 } 886 virtual void execute(DCmdSource source, TRAPS); 887 }; 888 889 #if INCLUDE_JVMTI 890 class DebugOnCmdStartDCmd : public DCmd { 891 public: 892 DebugOnCmdStartDCmd(outputStream* output, bool heap) : DCmd(output, heap) {} 893 static const char* name() { 894 return "VM.start_java_debugging"; 895 } 896 static const char* description() { 897 return "Starts up the Java debugging if the jdwp agentlib was enabled with the option onjcmd=y."; 898 } 899 static const char* impact() { 900 return "High: Switches the VM into Java debug mode."; 901 } 902 static const JavaPermission permission() { 903 JavaPermission p = { "java.lang.management.ManagementPermission", "control", nullptr }; 904 return p; 905 } 906 virtual void execute(DCmdSource source, TRAPS); 907 }; 908 #endif // INCLUDE_JVMTI 909 910 class EventLogDCmd : public DCmdWithParser { 911 protected: 912 DCmdArgument<char*> _log; 913 DCmdArgument<char*> _max; 914 public: 915 static int num_arguments() { return 2; } 916 EventLogDCmd(outputStream* output, bool heap); 917 static const char* name() { 918 return "VM.events"; 919 } 920 static const char* description() { 921 return "Print VM event logs"; 922 } 923 static const char* impact() { 924 return "Low: Depends on event log size. "; 925 } 926 static const JavaPermission permission() { 927 JavaPermission p = {"java.lang.management.ManagementPermission", 928 "monitor", nullptr}; 929 return p; 930 } 931 virtual void execute(DCmdSource source, TRAPS); 932 }; 933 934 class ThreadDumpToFileDCmd : public DCmdWithParser { 935 private: 936 void dumpToFile(Symbol* name, Symbol* signature, const char* path, bool overwrite, TRAPS); 937 protected: 938 DCmdArgument<bool> _overwrite; 939 DCmdArgument<char*> _format; 940 DCmdArgument<char*> _filepath; 941 public: 942 static int num_arguments() { return 3; } 943 ThreadDumpToFileDCmd(outputStream *output, bool heap); 944 static const char *name() { 945 return "Thread.dump_to_file"; 946 } 947 static const char *description() { 948 return "Dump threads, with stack traces, to a file in plain text or JSON format."; 949 } 950 static const char* impact() { 951 return "Medium: Depends on the number of threads."; 952 } 953 static const JavaPermission permission() { 954 JavaPermission p = {"java.lang.management.ManagementPermission", "monitor", nullptr}; 955 return p; 956 } 957 virtual void execute(DCmdSource source, TRAPS); 958 }; 959 960 class CompilationMemoryStatisticDCmd: public DCmdWithParser { 961 protected: 962 DCmdArgument<bool> _human_readable; 963 DCmdArgument<MemorySizeArgument> _minsize; 964 public: 965 static int num_arguments() { return 2; } 966 CompilationMemoryStatisticDCmd(outputStream* output, bool heap); 967 static const char* name() { 968 return "Compiler.memory"; 969 } 970 static const char* description() { 971 return "Print compilation footprint"; 972 } 973 static const char* impact() { 974 return "Medium: Pause time depends on number of compiled methods"; 975 } 976 static const JavaPermission permission() { 977 JavaPermission p = {"java.lang.management.ManagementPermission", 978 "monitor", nullptr}; 979 return p; 980 } 981 virtual void execute(DCmdSource source, TRAPS); 982 }; 983 984 #ifdef LINUX 985 986 class SystemMapDCmd : public DCmdWithParser { 987 DCmdArgument<bool> _human_readable; 988 public: 989 static int num_arguments() { return 1; } 990 SystemMapDCmd(outputStream* output, bool heap); 991 static const char* name() { return "System.map"; } 992 static const char* description() { 993 return "Prints an annotated process memory map of the VM process (linux only)."; 994 } 995 static const char* impact() { return "Low"; } 996 static const JavaPermission permission() { 997 JavaPermission p = {"java.lang.management.ManagementPermission", 998 "control", nullptr}; 999 return p; 1000 } 1001 virtual void execute(DCmdSource source, TRAPS); 1002 }; 1003 1004 class SystemDumpMapDCmd : public DCmdWithParser { 1005 DCmdArgument<bool> _human_readable; 1006 DCmdArgument<char*> _filename; 1007 public: 1008 static int num_arguments() { return 2; } 1009 SystemDumpMapDCmd(outputStream* output, bool heap); 1010 static const char* name() { return "System.dump_map"; } 1011 static const char* description() { 1012 return "Dumps an annotated process memory map to an output file (linux only)."; 1013 } 1014 static const char* impact() { return "Low"; } 1015 static const JavaPermission permission() { 1016 JavaPermission p = {"java.lang.management.ManagementPermission", 1017 "control", nullptr}; 1018 return p; 1019 } 1020 virtual void execute(DCmdSource source, TRAPS); 1021 }; 1022 1023 #endif // LINUX 1024 1025 #endif // SHARE_SERVICES_DIAGNOSTICCOMMAND_HPP