1 /*
   2  * Copyright (c) 2011, 2013, 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 "runtime/arguments.hpp"
  29 #include "classfile/vmSymbols.hpp"
  30 #include "utilities/ostream.hpp"
  31 #include "runtime/vm_version.hpp"
  32 #include "runtime/vmThread.hpp"
  33 #include "runtime/os.hpp"
  34 #include "services/diagnosticArgument.hpp"
  35 #include "services/diagnosticCommand.hpp"
  36 #include "services/diagnosticFramework.hpp"
  37 #include "services/diagnosticCommand_ext.hpp"
  38 
  39 class HelpDCmd : public DCmdWithParser {
  40 protected:
  41   DCmdArgument<bool> _all;
  42   DCmdArgument<char*> _cmd;
  43 public:
  44   HelpDCmd(outputStream* output, bool heap);
  45   static const char* name() { return "help"; }
  46   static const char* description() {
  47     return "For more information about a specific command use 'help <command>'. "
  48            "With no argument this will show a list of available commands. "
  49            "'help all' will show help for all commands.";
  50   }
  51   static const char* impact() { return "Low"; }
  52   static int num_arguments();
  53   virtual void execute(TRAPS);
  54 };
  55 
  56 class VersionDCmd : public DCmd {
  57 public:
  58   VersionDCmd(outputStream* output, bool heap) : DCmd(output,heap) { }
  59   static const char* name() { return "VM.version"; }
  60   static const char* description() {
  61     return "Print JVM version information.";
  62   }
  63   static const char* impact() { return "Low"; }
  64   static int num_arguments() { return 0; }
  65   virtual void execute(TRAPS);
  66 };
  67 
  68 class CommandLineDCmd : public DCmd {
  69 public:
  70   CommandLineDCmd(outputStream* output, bool heap) : DCmd(output, heap) { }
  71   static const char* name() { return "VM.command_line"; }
  72   static const char* description() {
  73     return "Print the command line used to start this VM instance.";
  74   }
  75   static const char* impact() { return "Low"; }
  76   static int num_arguments() { return 0; }
  77   virtual void execute(TRAPS) {
  78     Arguments::print_on(_output);
  79   }
  80 };
  81 
  82 // See also: get_system_properties in attachListener.cpp
  83 class PrintSystemPropertiesDCmd : public DCmd {
  84 public:
  85   PrintSystemPropertiesDCmd(outputStream* output, bool heap) : DCmd(output, heap) { }
  86     static const char* name() { return "VM.system_properties"; }
  87     static const char* description() {
  88       return "Print system properties.";
  89     }
  90     static const char* impact() {
  91       return "Low";
  92     }
  93     static int num_arguments() { return 0; }
  94     virtual void execute(TRAPS);
  95 };
  96 
  97 // See also: print_flag in attachListener.cpp
  98 class PrintVMFlagsDCmd : public DCmdWithParser {
  99 protected:
 100   DCmdArgument<bool> _all;
 101 public:
 102   PrintVMFlagsDCmd(outputStream* output, bool heap);
 103   static const char* name() { return "VM.flags"; }
 104   static const char* description() {
 105     return "Print VM flag options and their current values.";
 106   }
 107   static const char* impact() {
 108     return "Low";
 109   }
 110   static int num_arguments();
 111   virtual void execute(TRAPS);
 112 };
 113 
 114 class VMUptimeDCmd : public DCmdWithParser {
 115 protected:
 116   DCmdArgument<bool> _date;
 117 public:
 118   VMUptimeDCmd(outputStream* output, bool heap);
 119   static const char* name() { return "VM.uptime"; }
 120   static const char* description() {
 121     return "Print VM uptime.";
 122   }
 123   static const char* impact() {
 124     return "Low";
 125   }
 126   static int num_arguments();
 127   virtual void execute(TRAPS);
 128 };
 129 
 130 class SystemGCDCmd : public DCmd {
 131 public:
 132   SystemGCDCmd(outputStream* output, bool heap) : DCmd(output, heap) { }
 133     static const char* name() { return "GC.run"; }
 134     static const char* description() {
 135       return "Call java.lang.System.gc().";
 136     }
 137     static const char* impact() {
 138       return "Medium: Depends on Java heap size and content.";
 139     }
 140     static int num_arguments() { return 0; }
 141     virtual void execute(TRAPS);
 142 };
 143 
 144 class RunFinalizationDCmd : public DCmd {
 145 public:
 146   RunFinalizationDCmd(outputStream* output, bool heap) : DCmd(output, heap) { }
 147     static const char* name() { return "GC.run_finalization"; }
 148     static const char* description() {
 149       return "Call java.lang.System.runFinalization().";
 150     }
 151     static const char* impact() {
 152       return "Medium: Depends on Java content.";
 153     }
 154     static int num_arguments() { return 0; }
 155     virtual void execute(TRAPS);
 156 };
 157 
 158 #if INCLUDE_SERVICES   // Heap dumping supported
 159 // See also: dump_heap in attachListener.cpp
 160 class HeapDumpDCmd : public DCmdWithParser {
 161 protected:
 162   DCmdArgument<char*> _filename;
 163   DCmdArgument<bool>  _all;
 164 public:
 165   HeapDumpDCmd(outputStream* output, bool heap);
 166   static const char* name() {
 167     return "GC.heap_dump";
 168   }
 169   static const char* description() {
 170     return "Generate a HPROF format dump of the Java heap.";
 171   }
 172   static const char* impact() {
 173     return "High: Depends on Java heap size and content. "
 174            "Request a full GC unless the '-all' option is specified.";
 175   }
 176   static int num_arguments();
 177   virtual void execute(TRAPS);
 178 };
 179 #endif // INCLUDE_SERVICES
 180 
 181 // See also: inspectheap in attachListener.cpp
 182 class ClassHistogramDCmd : public DCmdWithParser {
 183 protected:
 184   DCmdArgument<bool> _all;
 185 public:
 186   ClassHistogramDCmd(outputStream* output, bool heap);
 187   static const char* name() {
 188     return "GC.class_histogram";
 189   }
 190   static const char* description() {
 191     return "Provide statistics about the Java heap usage.";
 192   }
 193   static const char* impact() {
 194     return "High: Depends on Java heap size and content.";
 195   }
 196   static int num_arguments();
 197   virtual void execute(TRAPS);
 198 };
 199 
 200 class ClassStatsDCmd : public DCmdWithParser {
 201 protected:
 202   DCmdArgument<bool> _all;
 203   DCmdArgument<bool> _csv;
 204   DCmdArgument<bool> _help;
 205   DCmdArgument<char*> _columns;
 206 public:
 207   ClassStatsDCmd(outputStream* output, bool heap);
 208   static const char* name() {
 209     return "GC.class_stats";
 210   }
 211   static const char* description() {
 212     return "Provide statistics about Java class meta data.";
 213   }
 214   static const char* impact() {
 215     return "High: Depends on Java heap size and content.";
 216   }
 217   static int num_arguments();
 218   virtual void execute(TRAPS);
 219 };
 220 
 221 // See also: thread_dump in attachListener.cpp
 222 class ThreadDumpDCmd : public DCmdWithParser {
 223 protected:
 224   DCmdArgument<bool> _locks;
 225 public:
 226   ThreadDumpDCmd(outputStream* output, bool heap);
 227   static const char* name() { return "Thread.print"; }
 228   static const char* description() {
 229     return "Print all threads with stacktraces.";
 230   }
 231   static const char* impact() {
 232     return "Medium: Depends on the number of threads.";
 233   }
 234   static int num_arguments();
 235   virtual void execute(TRAPS);
 236 };
 237 
 238 // Enhanced JMX Agent support
 239 
 240 class JMXStartRemoteDCmd : public DCmdWithParser {
 241 
 242   // Explicitly list all properties that could be
 243   // passed to Agent.startRemoteManagementAgent()
 244   // com.sun.management is omitted
 245 
 246   DCmdArgument<char *> _config_file;
 247   DCmdArgument<char *> _jmxremote_port;
 248   DCmdArgument<char *> _jmxremote_rmi_port;
 249   DCmdArgument<char *> _jmxremote_ssl;
 250   DCmdArgument<char *> _jmxremote_registry_ssl;
 251   DCmdArgument<char *> _jmxremote_authenticate;
 252   DCmdArgument<char *> _jmxremote_password_file;
 253   DCmdArgument<char *> _jmxremote_access_file;
 254   DCmdArgument<char *> _jmxremote_login_config;
 255   DCmdArgument<char *> _jmxremote_ssl_enabled_cipher_suites;
 256   DCmdArgument<char *> _jmxremote_ssl_enabled_protocols;
 257   DCmdArgument<char *> _jmxremote_ssl_need_client_auth;
 258   DCmdArgument<char *> _jmxremote_ssl_config_file;
 259 
 260 public:
 261   JMXStartRemoteDCmd(outputStream *output, bool heap_allocated);
 262 
 263   static const char *name() {
 264     return "ManagementAgent.start";
 265   }
 266 
 267   static const char *description() {
 268     return "Start remote management agent.";
 269   }
 270 
 271   static int num_arguments();
 272 
 273   virtual void execute(TRAPS);
 274 
 275 };
 276 
 277 class JMXStartLocalDCmd : public DCmd {
 278 
 279   // Explicitly request start of local agent,
 280   // it will not be started by start dcmd
 281 
 282 
 283 public:
 284   JMXStartLocalDCmd(outputStream *output, bool heap_allocated);
 285 
 286   static const char *name() {
 287     return "ManagementAgent.start_local";
 288   }
 289 
 290   static const char *description() {
 291     return "Start local management agent.";
 292   }
 293 
 294   virtual void execute(TRAPS);
 295 
 296 };
 297 
 298 class JMXStopRemoteDCmd : public DCmd {
 299 public:
 300   JMXStopRemoteDCmd(outputStream *output, bool heap_allocated) :
 301   DCmd(output, heap_allocated) {
 302     // Do Nothing
 303   }
 304 
 305   static const char *name() {
 306     return "ManagementAgent.stop";
 307   }
 308 
 309   static const char *description() {
 310     return "Stop remote management agent.";
 311   }
 312 
 313   virtual void execute(TRAPS);
 314 };
 315 
 316 #endif // SHARE_VM_SERVICES_DIAGNOSTICCOMMAND_HPP