# HG changeset patch # User fparain # Date 1326101244 -3600 # Node ID 4f25538b54c9fdcba0fc7001e4e0c2e1602befe9 # Parent 66259eca2bf7259c7248cb0febff3500cdb2b04c 7120511: Add diagnostic commands Reviewed-by: acorn, phh, dcubed, sspitsyn diff -r 66259eca2bf7 -r 4f25538b54c9 src/share/vm/classfile/vmSymbols.hpp --- a/src/share/vm/classfile/vmSymbols.hpp Thu Jan 05 17:16:13 2012 -0500 +++ b/src/share/vm/classfile/vmSymbols.hpp Mon Jan 09 10:27:24 2012 +0100 @@ -296,6 +296,7 @@ template(finalize_method_name, "finalize") \ template(reference_lock_name, "lock") \ template(reference_discovered_name, "discovered") \ + template(run_finalization_name, "runFinalization") \ template(run_finalizers_on_exit_name, "runFinalizersOnExit") \ template(uncaughtException_name, "uncaughtException") \ template(dispatchUncaughtException_name, "dispatchUncaughtException") \ diff -r 66259eca2bf7 -r 4f25538b54c9 src/share/vm/runtime/arguments.cpp --- a/src/share/vm/runtime/arguments.cpp Thu Jan 05 17:16:13 2012 -0500 +++ b/src/share/vm/runtime/arguments.cpp Mon Jan 09 10:27:24 2012 +0100 @@ -2323,7 +2323,7 @@ #ifndef PRODUCT // -Xprintflags } else if (match_option(option, "-Xprintflags", &tail)) { - CommandLineFlags::printFlags(); + CommandLineFlags::printFlags(tty, false); vm_exit(0); #endif // -D @@ -2971,13 +2971,13 @@ IgnoreUnrecognizedVMOptions = false; } if (match_option(option, "-XX:+PrintFlagsInitial", &tail)) { - CommandLineFlags::printFlags(); + CommandLineFlags::printFlags(tty, false); vm_exit(0); } #ifndef PRODUCT if (match_option(option, "-XX:+PrintFlagsWithComments", &tail)) { - CommandLineFlags::printFlags(true); + CommandLineFlags::printFlags(tty, true); vm_exit(0); } #endif @@ -3170,7 +3170,7 @@ #endif if (PrintCommandLineFlags) { - CommandLineFlags::printSetFlags(); + CommandLineFlags::printSetFlags(tty); } // Apply CPU specific policy for the BiasedLocking diff -r 66259eca2bf7 -r 4f25538b54c9 src/share/vm/runtime/globals.cpp --- a/src/share/vm/runtime/globals.cpp Thu Jan 05 17:16:13 2012 -0500 +++ b/src/share/vm/runtime/globals.cpp Mon Jan 09 10:27:24 2012 +0100 @@ -488,7 +488,7 @@ } } -void CommandLineFlags::printSetFlags() { +void CommandLineFlags::printSetFlags(outputStream* out) { // Print which flags were set on the command line // note: this method is called before the thread structure is in place // which means resource allocation cannot be used. @@ -507,11 +507,11 @@ // Print for (int i = 0; i < length; i++) { if (array[i]->origin /* naked field! */) { - array[i]->print_as_flag(tty); - tty->print(" "); + array[i]->print_as_flag(out); + out->print(" "); } } - tty->cr(); + out->cr(); FREE_C_HEAP_ARRAY(Flag*, array); } @@ -524,7 +524,7 @@ #endif // PRODUCT -void CommandLineFlags::printFlags(bool withComments) { +void CommandLineFlags::printFlags(outputStream* out, bool withComments) { // Print the flags sorted by name // note: this method is called before the thread structure is in place // which means resource allocation cannot be used. @@ -541,10 +541,10 @@ qsort(array, length, sizeof(Flag*), compare_flags); // Print - tty->print_cr("[Global flags]"); + out->print_cr("[Global flags]"); for (int i = 0; i < length; i++) { if (array[i]->is_unlocked()) { - array[i]->print_on(tty, withComments); + array[i]->print_on(out, withComments); } } FREE_C_HEAP_ARRAY(Flag*, array); diff -r 66259eca2bf7 -r 4f25538b54c9 src/share/vm/runtime/globals.hpp --- a/src/share/vm/runtime/globals.hpp Thu Jan 05 17:16:13 2012 -0500 +++ b/src/share/vm/runtime/globals.hpp Mon Jan 09 10:27:24 2012 +0100 @@ -326,9 +326,9 @@ // Returns false if name is not a command line flag. static bool wasSetOnCmdline(const char* name, bool* value); - static void printSetFlags(); + static void printSetFlags(outputStream* out); - static void printFlags(bool withComments = false ); + static void printFlags(outputStream* out, bool withComments); static void verify() PRODUCT_RETURN; }; diff -r 66259eca2bf7 -r 4f25538b54c9 src/share/vm/runtime/init.cpp --- a/src/share/vm/runtime/init.cpp Thu Jan 05 17:16:13 2012 -0500 +++ b/src/share/vm/runtime/init.cpp Mon Jan 09 10:27:24 2012 +0100 @@ -140,7 +140,7 @@ // All the flags that get adjusted by VM_Version_init and os::init_2 // have been set so dump the flags now. if (PrintFlagsFinal) { - CommandLineFlags::printFlags(); + CommandLineFlags::printFlags(tty, false); } return JNI_OK; diff -r 66259eca2bf7 -r 4f25538b54c9 src/share/vm/services/attachListener.cpp --- a/src/share/vm/services/attachListener.cpp Thu Jan 05 17:16:13 2012 -0500 +++ b/src/share/vm/services/attachListener.cpp Mon Jan 09 10:27:24 2012 +0100 @@ -99,6 +99,7 @@ } // Implementation of "properties" command. +// See also: PrintSystemPropertiesDCmd class static jint get_system_properties(AttachOperation* op, outputStream* out) { return get_properties(op, out, vmSymbols::serializePropertiesToByteArray_name()); } @@ -127,6 +128,7 @@ } // Implementation of "threaddump" command - essentially a remote ctrl-break +// See also: ThreadDumpDCmd class // static jint thread_dump(AttachOperation* op, outputStream* out) { bool print_concurrent_locks = false; @@ -158,6 +160,7 @@ DCmd::parse_and_execute(out, op->arg(0), ' ', THREAD); if (HAS_PENDING_EXCEPTION) { java_lang_Throwable::print(PENDING_EXCEPTION, out); + out->cr(); CLEAR_PENDING_EXCEPTION; // The exception has been printed on the output stream // If the JVM returns JNI_ERR, the attachAPI throws a generic I/O @@ -169,6 +172,7 @@ #ifndef SERVICES_KERNEL // Heap dumping not supported // Implementation of "dumpheap" command. +// See also: HeapDumpDCmd class // // Input arguments :- // arg0: Name of the dump file @@ -211,6 +215,7 @@ #endif // SERVICES_KERNEL // Implementation of "inspectheap" command +// See also: ClassHistogramDCmd class // // Input arguments :- // arg0: "-live" or "-all" @@ -354,6 +359,7 @@ } // Implementation of "printflag" command +// See also: PrintVMFlagsDCmd class static jint print_flag(AttachOperation* op, outputStream* out) { const char* name = NULL; if ((name = op->arg(0)) == NULL) { diff -r 66259eca2bf7 -r 4f25538b54c9 src/share/vm/services/diagnosticCommand.cpp --- a/src/share/vm/services/diagnosticCommand.cpp Thu Jan 05 17:16:13 2012 -0500 +++ b/src/share/vm/services/diagnosticCommand.cpp Mon Jan 09 10:27:24 2012 +0100 @@ -23,11 +23,15 @@ */ #include "precompiled.hpp" +#include "gc_implementation/shared/vmGCOperations.hpp" +#include "runtime/javaCalls.hpp" #include "services/diagnosticArgument.hpp" #include "services/diagnosticCommand.hpp" #include "services/diagnosticFramework.hpp" +#include "services/heapDumper.hpp" +#include "services/management.hpp" -HelpDCmd::HelpDCmd(outputStream* output, bool heap) : DCmd(output, heap), +HelpDCmd::HelpDCmd(outputStream* output, bool heap) : DCmdWithParser(output, heap), _all("-all", "Show help for all commands", "BOOLEAN", false, "false"), _cmd("command name", "The name of the command for which we want help", "STRING", false) { @@ -35,14 +39,6 @@ _dcmdparser.add_dcmd_argument(&_cmd); }; -void HelpDCmd::parse(CmdLine* line, char delim, TRAPS) { - _dcmdparser.parse(line, delim, CHECK); -} - -void HelpDCmd::print_help(outputStream* out) { - _dcmdparser.print_help(out, name()); -} - void HelpDCmd::execute(TRAPS) { if (_all.value()) { GrowableArray* cmd_list = DCmdFactory::DCmd_list(); @@ -66,10 +62,11 @@ factory->is_enabled() ? "" : " [disabled]"); output()->print_cr(factory->description()); output()->print_cr("\nImpact: %s", factory->impact()); + output()->cr(); cmd = factory->create_resource_instance(output()); if (cmd != NULL) { DCmdMark mark(cmd); - cmd->print_help(output()); + cmd->print_help(factory->name()); } } else { output()->print_cr("Help unavailable : '%s' : No such command", _cmd.value()); @@ -90,14 +87,6 @@ } } -void HelpDCmd::reset(TRAPS) { - _dcmdparser.reset(CHECK); -} - -void HelpDCmd::cleanup() { - _dcmdparser.cleanup(); -} - int HelpDCmd::num_arguments() { ResourceMark rm; HelpDCmd* dcmd = new HelpDCmd(NULL, false); @@ -109,14 +98,6 @@ } } -GrowableArray* HelpDCmd::argument_name_array() { - return _dcmdparser.argument_name_array(); -} - -GrowableArray* HelpDCmd::argument_info_array() { - return _dcmdparser.argument_info_array(); -} - void VersionDCmd::execute(TRAPS) { output()->print_cr("%s version %s", Abstract_VM_Version::vm_name(), Abstract_VM_Version::vm_release()); @@ -129,3 +110,210 @@ jdk_version.minor_version()); } } + +PrintVMFlagsDCmd::PrintVMFlagsDCmd(outputStream* output, bool heap) : + DCmdWithParser(output, heap), + _all("-all", "Print all flags supported by the VM", "BOOLEAN", false, "false") { + _dcmdparser.add_dcmd_option(&_all); +} + +void PrintVMFlagsDCmd::execute(TRAPS) { + if (_all.value()) { + CommandLineFlags::printFlags(output(), true); + } else { + CommandLineFlags::printSetFlags(output()); + } +} + +int PrintVMFlagsDCmd::num_arguments() { + ResourceMark rm; + PrintVMFlagsDCmd* dcmd = new PrintVMFlagsDCmd(NULL, false); + if (dcmd != NULL) { + DCmdMark mark(dcmd); + return dcmd->_dcmdparser.num_arguments(); + } else { + return 0; + } +} + +void PrintSystemPropertiesDCmd::execute(TRAPS) { + // load sun.misc.VMSupport + Symbol* klass = vmSymbols::sun_misc_VMSupport(); + klassOop k = SystemDictionary::resolve_or_fail(klass, true, CHECK); + instanceKlassHandle ik (THREAD, k); + if (ik->should_be_initialized()) { + ik->initialize(THREAD); + } + if (HAS_PENDING_EXCEPTION) { + java_lang_Throwable::print(PENDING_EXCEPTION, output()); + output()->cr(); + CLEAR_PENDING_EXCEPTION; + return; + } + + // invoke the serializePropertiesToByteArray method + JavaValue result(T_OBJECT); + JavaCallArguments args; + + Symbol* signature = vmSymbols::serializePropertiesToByteArray_signature(); + JavaCalls::call_static(&result, + ik, + vmSymbols::serializePropertiesToByteArray_name(), + signature, + &args, + THREAD); + if (HAS_PENDING_EXCEPTION) { + java_lang_Throwable::print(PENDING_EXCEPTION, output()); + output()->cr(); + CLEAR_PENDING_EXCEPTION; + return; + } + + // The result should be a [B + oop res = (oop)result.get_jobject(); + assert(res->is_typeArray(), "just checking"); + assert(typeArrayKlass::cast(res->klass())->element_type() == T_BYTE, "just checking"); + + // copy the bytes to the output stream + typeArrayOop ba = typeArrayOop(res); + jbyte* addr = typeArrayOop(res)->byte_at_addr(0); + output()->print_raw((const char*)addr, ba->length()); +} + +VMUptimeDCmd::VMUptimeDCmd(outputStream* output, bool heap) : + DCmdWithParser(output, heap), + _date("-date", "Add a prefix with current date", "BOOLEAN", false, "false") { + _dcmdparser.add_dcmd_option(&_date); +} + +void VMUptimeDCmd::execute(TRAPS) { + if (_date.value()) { + output()->date_stamp(true, "", ": "); + } + output()->time_stamp().update_to(tty->time_stamp().ticks()); + output()->stamp(); + output()->print_cr(" s"); +} + +int VMUptimeDCmd::num_arguments() { + ResourceMark rm; + VMUptimeDCmd* dcmd = new VMUptimeDCmd(NULL, false); + if (dcmd != NULL) { + DCmdMark mark(dcmd); + return dcmd->_dcmdparser.num_arguments(); + } else { + return 0; + } +} + +void SystemGCDCmd::execute(TRAPS) { + Universe::heap()->collect(GCCause::_java_lang_system_gc); +} + +void RunFinalizationDCmd::execute(TRAPS) { + klassOop k = SystemDictionary::resolve_or_fail(vmSymbols::java_lang_System(), + true, CHECK); + instanceKlassHandle klass(THREAD, k); + JavaValue result(T_VOID); + JavaCalls::call_static(&result, klass, + vmSymbols::run_finalization_name(), + vmSymbols::void_method_signature(), CHECK); +} + +#ifndef SERVICES_KERNEL // Heap dumping not supported +HeapDumpDCmd::HeapDumpDCmd(outputStream* output, bool heap) : + DCmdWithParser(output, heap), + _filename("filename","Name of the dump file", "STRING",true), + _all("-all", "Dump all objects, including unreachable objects", + "BOOLEAN", false, "false") { + _dcmdparser.add_dcmd_option(&_all); + _dcmdparser.add_dcmd_argument(&_filename); +} + +void HeapDumpDCmd::execute(TRAPS) { + // Request a full GC before heap dump if _all is false + // This helps reduces the amount of unreachable objects in the dump + // and makes it easier to browse. + HeapDumper dumper(!_all.value() /* request GC if _all is false*/); + int res = dumper.dump(_filename.value()); + if (res == 0) { + output()->print_cr("Heap dump file created"); + } else { + // heap dump failed + ResourceMark rm; + char* error = dumper.error_as_C_string(); + if (error == NULL) { + output()->print_cr("Dump failed - reason unknown"); + } else { + output()->print_cr("%s", error); + } + } +} + +int HeapDumpDCmd::num_arguments() { + ResourceMark rm; + HeapDumpDCmd* dcmd = new HeapDumpDCmd(NULL, false); + if (dcmd != NULL) { + DCmdMark mark(dcmd); + return dcmd->_dcmdparser.num_arguments(); + } else { + return 0; + } +} +#endif // SERVICES_KERNEL + +ClassHistogramDCmd::ClassHistogramDCmd(outputStream* output, bool heap) : + DCmdWithParser(output, heap), + _all("-all", "Inspect all objects, including unreachable objects", + "BOOLEAN", false, "false") { + _dcmdparser.add_dcmd_option(&_all); +} + +void ClassHistogramDCmd::execute(TRAPS) { + VM_GC_HeapInspection heapop(output(), + !_all.value() /* request full gc if false */, + true /* need_prologue */); + VMThread::execute(&heapop); +} + +int ClassHistogramDCmd::num_arguments() { + ResourceMark rm; + ClassHistogramDCmd* dcmd = new ClassHistogramDCmd(NULL, false); + if (dcmd != NULL) { + DCmdMark mark(dcmd); + return dcmd->_dcmdparser.num_arguments(); + } else { + return 0; + } +} + +ThreadDumpDCmd::ThreadDumpDCmd(outputStream* output, bool heap) : + DCmdWithParser(output, heap), + _locks("-l", "print java.util.concurrent locks", "BOOLEAN", false, "false") { + _dcmdparser.add_dcmd_option(&_locks); +} + +void ThreadDumpDCmd::execute(TRAPS) { + // thread stacks + VM_PrintThreads op1(output(), _locks.value()); + VMThread::execute(&op1); + + // JNI global handles + VM_PrintJNI op2(output()); + VMThread::execute(&op2); + + // Deadlock detection + VM_FindDeadlocks op3(output()); + VMThread::execute(&op3); +} + +int ThreadDumpDCmd::num_arguments() { + ResourceMark rm; + ThreadDumpDCmd* dcmd = new ThreadDumpDCmd(NULL, false); + if (dcmd != NULL) { + DCmdMark mark(dcmd); + return dcmd->_dcmdparser.num_arguments(); + } else { + return 0; + } +} diff -r 66259eca2bf7 -r 4f25538b54c9 src/share/vm/services/diagnosticCommand.hpp --- a/src/share/vm/services/diagnosticCommand.hpp Thu Jan 05 17:16:13 2012 -0500 +++ b/src/share/vm/services/diagnosticCommand.hpp Mon Jan 09 10:27:24 2012 +0100 @@ -35,9 +35,8 @@ #include "services/diagnosticCommand.hpp" #include "services/diagnosticFramework.hpp" -class HelpDCmd : public DCmd { +class HelpDCmd : public DCmdWithParser { protected: - DCmdParser _dcmdparser; DCmdArgument _all; DCmdArgument _cmd; public: @@ -50,13 +49,7 @@ } static const char* impact() { return "Low: "; } static int num_arguments(); - virtual void parse(CmdLine* line, char delim, TRAPS); virtual void execute(TRAPS); - virtual void reset(TRAPS); - virtual void cleanup(); - virtual void print_help(outputStream* out); - virtual GrowableArray* argument_name_array(); - virtual GrowableArray* argument_info_array(); }; class VersionDCmd : public DCmd { @@ -68,9 +61,156 @@ } static const char* impact() { return "Low: "; } static int num_arguments() { return 0; } - virtual void parse(CmdLine* line, char delim, TRAPS) { } + virtual void execute(TRAPS); +}; + +class CommandLineDCmd : public DCmd { +public: + CommandLineDCmd(outputStream* output, bool heap) : DCmd(output, heap) { } + static const char* name() { return "VM.command_line"; } + static const char* description() { + return "Print the command line used to start this VM instance."; + } + static const char* impact() { return "Low: "; } + static int num_arguments() { return 0; } + virtual void execute(TRAPS) { + Arguments::print_on(_output); + } +}; + +// See also: get_system_properties in attachListener.cpp +class PrintSystemPropertiesDCmd : public DCmd { +public: + PrintSystemPropertiesDCmd(outputStream* output, bool heap) : DCmd(output, heap) { } + static const char* name() { return "VM.system_properties"; } + static const char* description() { + return "Print system properties."; + } + static const char* impact() { + return "Low: "; + } + static int num_arguments() { return 0; } + virtual void execute(TRAPS); +}; + +// See also: print_flag in attachListener.cpp +class PrintVMFlagsDCmd : public DCmdWithParser { +protected: + DCmdArgument _all; +public: + PrintVMFlagsDCmd(outputStream* output, bool heap); + static const char* name() { return "VM.flags"; } + static const char* description() { + return "Print VM flag options and their current values."; + } + static const char* impact() { + return "Low: "; + } + static int num_arguments(); + virtual void execute(TRAPS); +}; + +class VMUptimeDCmd : public DCmdWithParser { +protected: + DCmdArgument _date; +public: + VMUptimeDCmd(outputStream* output, bool heap); + static const char* name() { return "VM.uptime"; } + static const char* description() { + return "Print VM uptime."; + } + static const char* impact() { + return "Low: "; + } + static int num_arguments(); virtual void execute(TRAPS); - virtual void print_help(outputStream* out) { } +}; + +class SystemGCDCmd : public DCmd { +public: + SystemGCDCmd(outputStream* output, bool heap) : DCmd(output, heap) { } + static const char* name() { return "GC.run"; } + static const char* description() { + return "Call java.lang.System.gc()."; + } + static const char* impact() { + return "Medium: Depends on Java heap size and content."; + } + static int num_arguments() { return 0; } + virtual void execute(TRAPS); +}; + +class RunFinalizationDCmd : public DCmd { +public: + RunFinalizationDCmd(outputStream* output, bool heap) : DCmd(output, heap) { } + static const char* name() { return "GC.run_finalization"; } + static const char* description() { + return "Call java.lang.System.runFinalization()."; + } + static const char* impact() { + return "Medium: Depends on Java content."; + } + static int num_arguments() { return 0; } + virtual void execute(TRAPS); +}; + +#ifndef SERVICES_KERNEL // Heap dumping not supported +// See also: dump_heap in attachListener.cpp +class HeapDumpDCmd : public DCmdWithParser { +protected: + DCmdArgument _filename; + DCmdArgument _all; +public: + HeapDumpDCmd(outputStream* output, bool heap); + static const char* name() { + return "GC.heap_dump"; + } + static const char* description() { + return "Generate a HPROF format dump of the Java heap."; + } + static const char* impact() { + return "High: Depends on Java heap size and content. " + "Request a full GC unless the '-all' option is specified."; + } + static int num_arguments(); + virtual void execute(TRAPS); +}; +#endif // SERVICES_KERNEL + +// See also: inspeactheap in attachListener.cpp +class ClassHistogramDCmd : public DCmdWithParser { +protected: + DCmdArgument _all; +public: + ClassHistogramDCmd(outputStream* output, bool heap); + static const char* name() { + return "GC.class_histogram"; + } + static const char* description() { + return "Provide statistics about the Java heap usage."; + } + static const char* impact() { + return "High: Depends on Java heap size and content."; + } + static int num_arguments(); + virtual void execute(TRAPS); +}; + +// See also: thread_dump in attachListener.cpp +class ThreadDumpDCmd : public DCmdWithParser { +protected: + DCmdArgument _locks; +public: + ThreadDumpDCmd(outputStream* output, bool heap); + static const char* name() { return "Thread.print"; } + static const char* description() { + return "Print all threads with stacktraces."; + } + static const char* impact() { + return "Medium: Depends on the number of threads."; + } + static int num_arguments(); + virtual void execute(TRAPS); }; #endif // SHARE_VM_SERVICES_DIAGNOSTICCOMMAND_HPP diff -r 66259eca2bf7 -r 4f25538b54c9 src/share/vm/services/diagnosticFramework.cpp --- a/src/share/vm/services/diagnosticFramework.cpp Thu Jan 05 17:16:13 2012 -0500 +++ b/src/share/vm/services/diagnosticFramework.cpp Mon Jan 09 10:27:24 2012 +0100 @@ -226,7 +226,7 @@ } void DCmdParser::print_help(outputStream* out, const char* cmd_name) { - out->print("\nSyntax : %s %s", cmd_name, _options == NULL ? "" : "[options]"); + out->print("Syntax : %s %s", cmd_name, _options == NULL ? "" : "[options]"); GenDCmdArgument* arg = _arguments_list; while (arg != NULL) { if (arg->is_mandatory()) { @@ -373,6 +373,30 @@ } } +void DCmdWithParser::parse(CmdLine* line, char delim, TRAPS) { + _dcmdparser.parse(line, delim, CHECK); +} + +void DCmdWithParser::print_help(const char* name) { + _dcmdparser.print_help(output(), name); +} + +void DCmdWithParser::reset(TRAPS) { + _dcmdparser.reset(CHECK); +} + +void DCmdWithParser::cleanup() { + _dcmdparser.cleanup(); +} + +GrowableArray* DCmdWithParser::argument_name_array() { + return _dcmdparser.argument_name_array(); +} + +GrowableArray* DCmdWithParser::argument_info_array() { + return _dcmdparser.argument_info_array(); +} + Mutex* DCmdFactory::_dcmdFactory_lock = new Mutex(Mutex::leaf, "DCmdFactory", true); DCmdFactory* DCmdFactory::factory(const char* name, size_t len) { diff -r 66259eca2bf7 -r 4f25538b54c9 src/share/vm/services/diagnosticFramework.hpp --- a/src/share/vm/services/diagnosticFramework.hpp Thu Jan 05 17:16:13 2012 -0500 +++ b/src/share/vm/services/diagnosticFramework.hpp Mon Jan 09 10:27:24 2012 +0100 @@ -241,8 +241,17 @@ static int num_arguments() { return 0; } outputStream* output() { return _output; } bool is_heap_allocated() { return _is_heap_allocated; } - virtual void print_help(outputStream* out) { }; - virtual void parse(CmdLine* line, char delim, TRAPS) { } + virtual void print_help(const char* name) { + output()->print_cr("Syntax: %s", name); + } + virtual void parse(CmdLine* line, char delim, TRAPS) { + DCmdArgIter iter(line->args_addr(), line->args_len(), delim); + bool has_arg = iter.next(CHECK); + if (has_arg) { + THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(), + "Unknown argument in diagnostic command"); + } + } virtual void execute(TRAPS) { } virtual void reset(TRAPS) { } virtual void cleanup() { } @@ -262,6 +271,25 @@ char delim, TRAPS); }; +class DCmdWithParser : public DCmd { +protected: + DCmdParser _dcmdparser; +public: + DCmdWithParser (outputStream *output, bool heap=false) : DCmd(output, heap) { } + static const char* name() { return "No Name";} + static const char* description() { return "No Help";} + static const char* disabled_message() { return "Diagnostic command currently disabled"; } + static const char* impact() { return "Low: No impact"; } + static int num_arguments() { return 0; } + virtual void parse(CmdLine *line, char delim, TRAPS); + virtual void execute(TRAPS) { } + virtual void reset(TRAPS); + virtual void cleanup(); + virtual void print_help(const char* name); + virtual GrowableArray* argument_name_array(); + virtual GrowableArray* argument_info_array(); +}; + class DCmdMark : public StackObj { DCmd* _ref; public: diff -r 66259eca2bf7 -r 4f25538b54c9 src/share/vm/services/management.cpp --- a/src/share/vm/services/management.cpp Thu Jan 05 17:16:13 2012 -0500 +++ b/src/share/vm/services/management.cpp Mon Jan 09 10:27:24 2012 +0100 @@ -118,8 +118,22 @@ #endif // SERVICES_KERNEL _optional_support.isThreadAllocatedMemorySupported = 1; + // Registration of the diagnostic commands + // First boolean argument specifies if the command is enabled + // Second boolean argument specifies if the command is hidden DCmdFactory::register_DCmdFactory(new DCmdFactoryImpl(true, false)); DCmdFactory::register_DCmdFactory(new DCmdFactoryImpl(true, false)); + DCmdFactory::register_DCmdFactory(new DCmdFactoryImpl(true, false)); + DCmdFactory::register_DCmdFactory(new DCmdFactoryImpl(true, false)); + DCmdFactory::register_DCmdFactory(new DCmdFactoryImpl(true, false)); + DCmdFactory::register_DCmdFactory(new DCmdFactoryImpl(true, false)); + DCmdFactory::register_DCmdFactory(new DCmdFactoryImpl(true, false)); + DCmdFactory::register_DCmdFactory(new DCmdFactoryImpl(true, false)); +#ifndef SERVICES_KERNEL // Heap dumping not supported + DCmdFactory::register_DCmdFactory(new DCmdFactoryImpl(true, false)); +#endif // SERVICES_KERNEL + DCmdFactory::register_DCmdFactory(new DCmdFactoryImpl(true, false)); + DCmdFactory::register_DCmdFactory(new DCmdFactoryImpl(true, false)); } void Management::initialize(TRAPS) {