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