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