jdk8-mips64-public/hotspot: src/share/vm/services/diagnosticCommand.hpp@645162d94294

7110104: It should be possible to stop and start JMX Agent at runtime
Summary: Added a capability to start and stop JMX Agent by jcmd
Reviewed-by: acorn, mchung

     1 /*

     2  * Copyright (c) 2011, 2012, 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  */

    25 #ifndef SHARE_VM_SERVICES_DIAGNOSTICCOMMAND_HPP

    26 #define SHARE_VM_SERVICES_DIAGNOSTICCOMMAND_HPP

    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"

    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 };

    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 };

    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 };

    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 };

    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 };

   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 };

   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 };

   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 };

   158 #ifndef SERVICES_KERNEL   // Heap dumping not 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 // SERVICES_KERNEL

   181 // See also: inspeactheap 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 };

   200 // See also: thread_dump in attachListener.cpp

   201 class ThreadDumpDCmd : public DCmdWithParser {

   202 protected:

   203   DCmdArgument<bool> _locks;

   204 public:

   205   ThreadDumpDCmd(outputStream* output, bool heap);

   206   static const char* name() { return "Thread.print"; }

   207   static const char* description() {

   208     return "Print all threads with stacktraces.";

   209   }

   210   static const char* impact() {

   211     return "Medium: Depends on the number of threads.";

   212   }

   213   static int num_arguments();

   214   virtual void execute(TRAPS);

   215 };

   217 // Enhanced JMX Agent support

   219 class JMXStartRemoteDCmd : public DCmdWithParser {

   221   // Explicitly list all properties that could be

   222   // passed to Agent.startRemoteManagementAgent()

   223   // com.sun.management is omitted

   225   DCmdArgument<char *> _config_file;

   226   DCmdArgument<char *> _jmxremote_port;

   227   DCmdArgument<char *> _jmxremote_rmi_port;

   228   DCmdArgument<char *> _jmxremote_ssl;

   229   DCmdArgument<char *> _jmxremote_registry_ssl;

   230   DCmdArgument<char *> _jmxremote_authenticate;

   231   DCmdArgument<char *> _jmxremote_password_file;

   232   DCmdArgument<char *> _jmxremote_access_file;

   233   DCmdArgument<char *> _jmxremote_login_config;

   234   DCmdArgument<char *> _jmxremote_ssl_enabled_cipher_suites;

   235   DCmdArgument<char *> _jmxremote_ssl_enabled_protocols;

   236   DCmdArgument<char *> _jmxremote_ssl_need_client_auth;

   237   DCmdArgument<char *> _jmxremote_ssl_config_file;

   239 public:

   240   JMXStartRemoteDCmd(outputStream *output, bool heap_allocated);

   242   static const char *name() {

   243     return "ManagementAgent.start";

   244   }

   246   static const char *description() {

   247     return "Start remote management agent.";

   248   }

   250   static int num_arguments();

   252   virtual void execute(TRAPS);

   254 };

   256 class JMXStartLocalDCmd : public DCmd {

   258   // Explicitly request start of local agent,

   259   // it will not be started by start dcmd

   262 public:

   263   JMXStartLocalDCmd(outputStream *output, bool heap_allocated);

   265   static const char *name() {

   266     return "ManagementAgent.start_local";

   267   }

   269   static const char *description() {

   270     return "Start local management agent.";

   271   }

   273   virtual void execute(TRAPS);

   275 };

   277 class JMXStopRemoteDCmd : public DCmd {

   278 public:

   279   JMXStopRemoteDCmd(outputStream *output, bool heap_allocated) :

   280   DCmd(output, heap_allocated) {

   281     // Do Nothing

   282   }

   284   static const char *name() {

   285     return "ManagementAgent.stop";

   286   }

   288   static const char *description() {

   289     return "Stop remote management agent.";

   290   }

   292   virtual void execute(TRAPS);

   293 };

   295 #endif // SHARE_VM_SERVICES_DIAGNOSTICCOMMAND_HPP

Mercurial > jdk8-mips64-public > hotspot / file revision

src/share/vm/services/diagnosticCommand.hpp@645162d94294

src/share/vm/services/diagnosticCommand.hpp