1 /*
   2  * Copyright (c) 2011, 2015, 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 #include "precompiled.hpp"
  26 #include "classfile/classLoaderStats.hpp"
  27 #include "classfile/compactHashtable.hpp"
  28 #include "compiler/compileBroker.hpp"
  29 #include "compiler/directivesParser.hpp"
  30 #include "gc/shared/vmGCOperations.hpp"
  31 #include "oops/oop.inline.hpp"
  32 #include "runtime/globals.hpp"
  33 #include "runtime/javaCalls.hpp"
  34 #include "runtime/os.hpp"
  35 #include "services/diagnosticArgument.hpp"
  36 #include "services/diagnosticCommand.hpp"
  37 #include "services/diagnosticFramework.hpp"
  38 #include "services/heapDumper.hpp"
  39 #include "services/management.hpp"
  40 #include "services/writeableFlags.hpp"
  41 #include "utilities/macros.hpp"
  42 #include "oops/objArrayOop.inline.hpp"
  43 
  44 void DCmdRegistrant::register_dcmds(){
  45   // Registration of the diagnostic commands
  46   // First argument specifies which interfaces will export the command
  47   // Second argument specifies if the command is enabled
  48   // Third  argument specifies if the command is hidden
  49   uint32_t full_export = DCmd_Source_Internal | DCmd_Source_AttachAPI
  50                          | DCmd_Source_MBean;
  51   DCmdFactory::register_DCmdFactory(new DCmdFactoryImpl<HelpDCmd>(full_export, true, false));
  52   DCmdFactory::register_DCmdFactory(new DCmdFactoryImpl<VersionDCmd>(full_export, true, false));
  53   DCmdFactory::register_DCmdFactory(new DCmdFactoryImpl<CommandLineDCmd>(full_export, true, false));
  54   DCmdFactory::register_DCmdFactory(new DCmdFactoryImpl<PrintSystemPropertiesDCmd>(full_export, true, false));
  55   DCmdFactory::register_DCmdFactory(new DCmdFactoryImpl<PrintVMFlagsDCmd>(full_export, true, false));
  56   DCmdFactory::register_DCmdFactory(new DCmdFactoryImpl<SetVMFlagDCmd>(full_export, true, false));
  57   DCmdFactory::register_DCmdFactory(new DCmdFactoryImpl<VMDynamicLibrariesDCmd>(full_export, true, false));
  58   DCmdFactory::register_DCmdFactory(new DCmdFactoryImpl<VMUptimeDCmd>(full_export, true, false));
  59   DCmdFactory::register_DCmdFactory(new DCmdFactoryImpl<VMInfoDCmd>(full_export, true, false));
  60   DCmdFactory::register_DCmdFactory(new DCmdFactoryImpl<SystemGCDCmd>(full_export, true, false));
  61   DCmdFactory::register_DCmdFactory(new DCmdFactoryImpl<RunFinalizationDCmd>(full_export, true, false));
  62   DCmdFactory::register_DCmdFactory(new DCmdFactoryImpl<HeapInfoDCmd>(full_export, true, false));
  63   DCmdFactory::register_DCmdFactory(new DCmdFactoryImpl<FinalizerInfoDCmd>(full_export, true, false));
  64 #if INCLUDE_SERVICES // Heap dumping/inspection supported
  65   DCmdFactory::register_DCmdFactory(new DCmdFactoryImpl<HeapDumpDCmd>(DCmd_Source_Internal | DCmd_Source_AttachAPI, true, false));
  66   DCmdFactory::register_DCmdFactory(new DCmdFactoryImpl<ClassHistogramDCmd>(full_export, true, false));
  67   DCmdFactory::register_DCmdFactory(new DCmdFactoryImpl<ClassStatsDCmd>(full_export, true, false));
  68   DCmdFactory::register_DCmdFactory(new DCmdFactoryImpl<ClassHierarchyDCmd>(full_export, true, false));
  69   DCmdFactory::register_DCmdFactory(new DCmdFactoryImpl<SymboltableDCmd>(full_export, true, false));
  70   DCmdFactory::register_DCmdFactory(new DCmdFactoryImpl<StringtableDCmd>(full_export, true, false));
  71 #endif // INCLUDE_SERVICES
  72 #if INCLUDE_JVMTI
  73   DCmdFactory::register_DCmdFactory(new DCmdFactoryImpl<JVMTIDataDumpDCmd>(full_export, true, false));
  74 #endif // INCLUDE_JVMTI
  75   DCmdFactory::register_DCmdFactory(new DCmdFactoryImpl<ThreadDumpDCmd>(full_export, true, false));
  76   DCmdFactory::register_DCmdFactory(new DCmdFactoryImpl<RotateGCLogDCmd>(full_export, true, false));
  77   DCmdFactory::register_DCmdFactory(new DCmdFactoryImpl<ClassLoaderStatsDCmd>(full_export, true, false));
  78   DCmdFactory::register_DCmdFactory(new DCmdFactoryImpl<CompileQueueDCmd>(full_export, true, false));
  79   DCmdFactory::register_DCmdFactory(new DCmdFactoryImpl<CodeListDCmd>(full_export, true, false));
  80   DCmdFactory::register_DCmdFactory(new DCmdFactoryImpl<CodeCacheDCmd>(full_export, true, false));
  81   DCmdFactory::register_DCmdFactory(new DCmdFactoryImpl<TouchedMethodsDCmd>(full_export, true, false));
  82 
  83   DCmdFactory::register_DCmdFactory(new DCmdFactoryImpl<CompilerDirectivesPrintDCmd>(full_export, true, false));
  84   DCmdFactory::register_DCmdFactory(new DCmdFactoryImpl<CompilerDirectivesAddDCmd>(full_export, true, false));
  85   DCmdFactory::register_DCmdFactory(new DCmdFactoryImpl<CompilerDirectivesRemoveDCmd>(full_export, true, false));
  86   DCmdFactory::register_DCmdFactory(new DCmdFactoryImpl<CompilerDirectivesClearDCmd>(full_export, true, false));
  87 
  88   // Enhanced JMX Agent Support
  89   // These commands won't be exported via the DiagnosticCommandMBean until an
  90   // appropriate permission is created for them
  91   uint32_t jmx_agent_export_flags = DCmd_Source_Internal | DCmd_Source_AttachAPI;
  92   DCmdFactory::register_DCmdFactory(new DCmdFactoryImpl<JMXStartRemoteDCmd>(jmx_agent_export_flags, true,false));
  93   DCmdFactory::register_DCmdFactory(new DCmdFactoryImpl<JMXStartLocalDCmd>(jmx_agent_export_flags, true,false));
  94   DCmdFactory::register_DCmdFactory(new DCmdFactoryImpl<JMXStopRemoteDCmd>(jmx_agent_export_flags, true,false));
  95   DCmdFactory::register_DCmdFactory(new DCmdFactoryImpl<JMXStatusDCmd>(jmx_agent_export_flags, true,false));
  96 
  97 }
  98 
  99 #ifndef HAVE_EXTRA_DCMD
 100 void DCmdRegistrant::register_dcmds_ext(){
 101    // Do nothing here
 102 }
 103 #endif
 104 
 105 
 106 HelpDCmd::HelpDCmd(outputStream* output, bool heap) : DCmdWithParser(output, heap),
 107   _all("-all", "Show help for all commands", "BOOLEAN", false, "false"),
 108   _cmd("command name", "The name of the command for which we want help",
 109         "STRING", false) {
 110   _dcmdparser.add_dcmd_option(&_all);
 111   _dcmdparser.add_dcmd_argument(&_cmd);
 112 };
 113 
 114 void HelpDCmd::execute(DCmdSource source, TRAPS) {
 115   if (_all.value()) {
 116     GrowableArray<const char*>* cmd_list = DCmdFactory::DCmd_list(source);
 117     for (int i = 0; i < cmd_list->length(); i++) {
 118       DCmdFactory* factory = DCmdFactory::factory(source, cmd_list->at(i),
 119                                                   strlen(cmd_list->at(i)));
 120       output()->print_cr("%s%s", factory->name(),
 121                          factory->is_enabled() ? "" : " [disabled]");
 122       output()->print_cr("\t%s", factory->description());
 123       output()->cr();
 124       factory = factory->next();
 125     }
 126   } else if (_cmd.has_value()) {
 127     DCmd* cmd = NULL;
 128     DCmdFactory* factory = DCmdFactory::factory(source, _cmd.value(),
 129                                                 strlen(_cmd.value()));
 130     if (factory != NULL) {
 131       output()->print_cr("%s%s", factory->name(),
 132                          factory->is_enabled() ? "" : " [disabled]");
 133       output()->print_cr("%s", factory->description());
 134       output()->print_cr("\nImpact: %s", factory->impact());
 135       JavaPermission p = factory->permission();
 136       if(p._class != NULL) {
 137         if(p._action != NULL) {
 138           output()->print_cr("\nPermission: %s(%s, %s)",
 139                   p._class, p._name == NULL ? "null" : p._name, p._action);
 140         } else {
 141           output()->print_cr("\nPermission: %s(%s)",
 142                   p._class, p._name == NULL ? "null" : p._name);
 143         }
 144       }
 145       output()->cr();
 146       cmd = factory->create_resource_instance(output());
 147       if (cmd != NULL) {
 148         DCmdMark mark(cmd);
 149         cmd->print_help(factory->name());
 150       }
 151     } else {
 152       output()->print_cr("Help unavailable : '%s' : No such command", _cmd.value());
 153     }
 154   } else {
 155     output()->print_cr("The following commands are available:");
 156     GrowableArray<const char *>* cmd_list = DCmdFactory::DCmd_list(source);
 157     for (int i = 0; i < cmd_list->length(); i++) {
 158       DCmdFactory* factory = DCmdFactory::factory(source, cmd_list->at(i),
 159                                                   strlen(cmd_list->at(i)));
 160       output()->print_cr("%s%s", factory->name(),
 161                          factory->is_enabled() ? "" : " [disabled]");
 162       factory = factory->_next;
 163     }
 164     output()->print_cr("\nFor more information about a specific command use 'help <command>'.");
 165   }
 166 }
 167 
 168 int HelpDCmd::num_arguments() {
 169   ResourceMark rm;
 170   HelpDCmd* dcmd = new HelpDCmd(NULL, false);
 171   if (dcmd != NULL) {
 172     DCmdMark mark(dcmd);
 173     return dcmd->_dcmdparser.num_arguments();
 174   } else {
 175     return 0;
 176   }
 177 }
 178 
 179 void VersionDCmd::execute(DCmdSource source, TRAPS) {
 180   output()->print_cr("%s version %s", Abstract_VM_Version::vm_name(),
 181           Abstract_VM_Version::vm_release());
 182   JDK_Version jdk_version = JDK_Version::current();
 183   if (jdk_version.update_version() > 0) {
 184     output()->print_cr("JDK %d.%d_%02d", jdk_version.major_version(),
 185             jdk_version.minor_version(), jdk_version.update_version());
 186   } else {
 187     output()->print_cr("JDK %d.%d", jdk_version.major_version(),
 188             jdk_version.minor_version());
 189   }
 190 }
 191 
 192 PrintVMFlagsDCmd::PrintVMFlagsDCmd(outputStream* output, bool heap) :
 193                                    DCmdWithParser(output, heap),
 194   _all("-all", "Print all flags supported by the VM", "BOOLEAN", false, "false") {
 195   _dcmdparser.add_dcmd_option(&_all);
 196 }
 197 
 198 void PrintVMFlagsDCmd::execute(DCmdSource source, TRAPS) {
 199   if (_all.value()) {
 200     CommandLineFlags::printFlags(output(), true);
 201   } else {
 202     CommandLineFlags::printSetFlags(output());
 203   }
 204 }
 205 
 206 int PrintVMFlagsDCmd::num_arguments() {
 207     ResourceMark rm;
 208     PrintVMFlagsDCmd* dcmd = new PrintVMFlagsDCmd(NULL, false);
 209     if (dcmd != NULL) {
 210       DCmdMark mark(dcmd);
 211       return dcmd->_dcmdparser.num_arguments();
 212     } else {
 213       return 0;
 214     }
 215 }
 216 
 217 SetVMFlagDCmd::SetVMFlagDCmd(outputStream* output, bool heap) :
 218                                    DCmdWithParser(output, heap),
 219   _flag("flag name", "The name of the flag we want to set",
 220         "STRING", true),
 221   _value("string value", "The value we want to set", "STRING", false) {
 222   _dcmdparser.add_dcmd_argument(&_flag);
 223   _dcmdparser.add_dcmd_argument(&_value);
 224 }
 225 
 226 void SetVMFlagDCmd::execute(DCmdSource source, TRAPS) {
 227   const char* val = NULL;
 228   if (_value.value() != NULL) {
 229     val = _value.value();
 230   }
 231 
 232   FormatBuffer<80> err_msg("%s", "");
 233   int ret = WriteableFlags::set_flag(_flag.value(), val, Flag::MANAGEMENT, err_msg);
 234 
 235   if (ret != Flag::SUCCESS) {
 236     output()->print_cr("%s", err_msg.buffer());
 237   }
 238 }
 239 
 240 int SetVMFlagDCmd::num_arguments() {
 241   ResourceMark rm;
 242   SetVMFlagDCmd* dcmd = new SetVMFlagDCmd(NULL, false);
 243   if (dcmd != NULL) {
 244     DCmdMark mark(dcmd);
 245     return dcmd->_dcmdparser.num_arguments();
 246   } else {
 247     return 0;
 248   }
 249 }
 250 
 251 void JVMTIDataDumpDCmd::execute(DCmdSource source, TRAPS) {
 252   if (JvmtiExport::should_post_data_dump()) {
 253     JvmtiExport::post_data_dump();
 254   }
 255 }
 256 
 257 void PrintSystemPropertiesDCmd::execute(DCmdSource source, TRAPS) {
 258   // load sun.misc.VMSupport
 259   Symbol* klass = vmSymbols::sun_misc_VMSupport();
 260   Klass* k = SystemDictionary::resolve_or_fail(klass, true, CHECK);
 261   instanceKlassHandle ik (THREAD, k);
 262   if (ik->should_be_initialized()) {
 263     ik->initialize(THREAD);
 264   }
 265   if (HAS_PENDING_EXCEPTION) {
 266     java_lang_Throwable::print(PENDING_EXCEPTION, output());
 267     output()->cr();
 268     CLEAR_PENDING_EXCEPTION;
 269     return;
 270   }
 271 
 272   // invoke the serializePropertiesToByteArray method
 273   JavaValue result(T_OBJECT);
 274   JavaCallArguments args;
 275 
 276   Symbol* signature = vmSymbols::serializePropertiesToByteArray_signature();
 277   JavaCalls::call_static(&result,
 278                          ik,
 279                          vmSymbols::serializePropertiesToByteArray_name(),
 280                          signature,
 281                          &args,
 282                          THREAD);
 283   if (HAS_PENDING_EXCEPTION) {
 284     java_lang_Throwable::print(PENDING_EXCEPTION, output());
 285     output()->cr();
 286     CLEAR_PENDING_EXCEPTION;
 287     return;
 288   }
 289 
 290   // The result should be a [B
 291   oop res = (oop)result.get_jobject();
 292   assert(res->is_typeArray(), "just checking");
 293   assert(TypeArrayKlass::cast(res->klass())->element_type() == T_BYTE, "just checking");
 294 
 295   // copy the bytes to the output stream
 296   typeArrayOop ba = typeArrayOop(res);
 297   jbyte* addr = typeArrayOop(res)->byte_at_addr(0);
 298   output()->print_raw((const char*)addr, ba->length());
 299 }
 300 
 301 VMUptimeDCmd::VMUptimeDCmd(outputStream* output, bool heap) :
 302                            DCmdWithParser(output, heap),
 303   _date("-date", "Add a prefix with current date", "BOOLEAN", false, "false") {
 304   _dcmdparser.add_dcmd_option(&_date);
 305 }
 306 
 307 void VMUptimeDCmd::execute(DCmdSource source, TRAPS) {
 308   if (_date.value()) {
 309     output()->date_stamp(true, "", ": ");
 310   }
 311   output()->time_stamp().update_to(tty->time_stamp().ticks());
 312   output()->stamp();
 313   output()->print_cr(" s");
 314 }
 315 
 316 int VMUptimeDCmd::num_arguments() {
 317   ResourceMark rm;
 318   VMUptimeDCmd* dcmd = new VMUptimeDCmd(NULL, false);
 319   if (dcmd != NULL) {
 320     DCmdMark mark(dcmd);
 321     return dcmd->_dcmdparser.num_arguments();
 322   } else {
 323     return 0;
 324   }
 325 }
 326 
 327 void VMInfoDCmd::execute(DCmdSource source, TRAPS) {
 328   VMError::print_vm_info(_output);
 329 }
 330 
 331 void SystemGCDCmd::execute(DCmdSource source, TRAPS) {
 332   if (!DisableExplicitGC) {
 333     Universe::heap()->collect(GCCause::_dcmd_gc_run);
 334   } else {
 335     output()->print_cr("Explicit GC is disabled, no GC has been performed.");
 336   }
 337 }
 338 
 339 void RunFinalizationDCmd::execute(DCmdSource source, TRAPS) {
 340   Klass* k = SystemDictionary::resolve_or_fail(vmSymbols::java_lang_System(),
 341                                                  true, CHECK);
 342   instanceKlassHandle klass(THREAD, k);
 343   JavaValue result(T_VOID);
 344   JavaCalls::call_static(&result, klass,
 345                          vmSymbols::run_finalization_name(),
 346                          vmSymbols::void_method_signature(), CHECK);
 347 }
 348 
 349 void HeapInfoDCmd::execute(DCmdSource source, TRAPS) {
 350   Universe::heap()->print_on(output());
 351 }
 352 
 353 void FinalizerInfoDCmd::execute(DCmdSource source, TRAPS) {
 354   ResourceMark rm;
 355 
 356 
 357   Klass* k = SystemDictionary::resolve_or_null(
 358     vmSymbols::finalizer_histogram_klass(), THREAD);
 359   assert(k != NULL, "FinalizerHistogram class is not accessible");
 360 
 361   instanceKlassHandle klass(THREAD, k);
 362   JavaValue result(T_ARRAY);
 363 
 364   // We are calling lang.ref.FinalizerHistogram.getFinalizerHistogram() method
 365   // and expect it to return array of FinalizerHistogramEntry as Object[]
 366 
 367   JavaCalls::call_static(&result, klass,
 368                          vmSymbols::get_finalizer_histogram_name(),
 369                          vmSymbols::void_finalizer_histogram_entry_array_signature(), CHECK);
 370 
 371   objArrayOop result_oop = (objArrayOop) result.get_jobject();
 372   if (result_oop->length() == 0) {
 373     output()->print_cr("No instances waiting for finalization found");
 374     return;
 375   }
 376 
 377   oop foop = result_oop->obj_at(0);
 378   InstanceKlass* ik = InstanceKlass::cast(foop->klass());
 379 
 380   fieldDescriptor count_fd, name_fd;
 381 
 382   Klass* count_res = ik->find_field(
 383     vmSymbols::finalizer_histogram_entry_count_field(), vmSymbols::int_signature(), &count_fd);
 384 
 385   Klass* name_res = ik->find_field(
 386     vmSymbols::finalizer_histogram_entry_name_field(), vmSymbols::string_signature(), &name_fd);
 387 
 388   assert(count_res != NULL && name_res != NULL, "Unexpected layout of FinalizerHistogramEntry");
 389 
 390   output()->print_cr("Unreachable instances waiting for finalization");
 391   output()->print_cr("#instances  class name");
 392   output()->print_cr("-----------------------");
 393 
 394   for (int i = 0; i < result_oop->length(); ++i) {
 395     oop element_oop = result_oop->obj_at(i);
 396     oop str_oop = element_oop->obj_field(name_fd.offset());
 397     char *name = java_lang_String::as_utf8_string(str_oop);
 398     int count = element_oop->int_field(count_fd.offset());
 399     output()->print_cr("%10d  %s", count, name);
 400   }
 401 }
 402 
 403 #if INCLUDE_SERVICES // Heap dumping/inspection supported
 404 HeapDumpDCmd::HeapDumpDCmd(outputStream* output, bool heap) :
 405                            DCmdWithParser(output, heap),
 406   _filename("filename","Name of the dump file", "STRING",true),
 407   _all("-all", "Dump all objects, including unreachable objects",
 408        "BOOLEAN", false, "false") {
 409   _dcmdparser.add_dcmd_option(&_all);
 410   _dcmdparser.add_dcmd_argument(&_filename);
 411 }
 412 
 413 void HeapDumpDCmd::execute(DCmdSource source, TRAPS) {
 414   // Request a full GC before heap dump if _all is false
 415   // This helps reduces the amount of unreachable objects in the dump
 416   // and makes it easier to browse.
 417   HeapDumper dumper(!_all.value() /* request GC if _all is false*/);
 418   int res = dumper.dump(_filename.value());
 419   if (res == 0) {
 420     output()->print_cr("Heap dump file created");
 421   } else {
 422     // heap dump failed
 423     ResourceMark rm;
 424     char* error = dumper.error_as_C_string();
 425     if (error == NULL) {
 426       output()->print_cr("Dump failed - reason unknown");
 427     } else {
 428       output()->print_cr("%s", error);
 429     }
 430   }
 431 }
 432 
 433 int HeapDumpDCmd::num_arguments() {
 434   ResourceMark rm;
 435   HeapDumpDCmd* dcmd = new HeapDumpDCmd(NULL, false);
 436   if (dcmd != NULL) {
 437     DCmdMark mark(dcmd);
 438     return dcmd->_dcmdparser.num_arguments();
 439   } else {
 440     return 0;
 441   }
 442 }
 443 
 444 ClassHistogramDCmd::ClassHistogramDCmd(outputStream* output, bool heap) :
 445                                        DCmdWithParser(output, heap),
 446   _all("-all", "Inspect all objects, including unreachable objects",
 447        "BOOLEAN", false, "false") {
 448   _dcmdparser.add_dcmd_option(&_all);
 449 }
 450 
 451 void ClassHistogramDCmd::execute(DCmdSource source, TRAPS) {
 452   VM_GC_HeapInspection heapop(output(),
 453                               !_all.value() /* request full gc if false */);
 454   VMThread::execute(&heapop);
 455 }
 456 
 457 int ClassHistogramDCmd::num_arguments() {
 458   ResourceMark rm;
 459   ClassHistogramDCmd* dcmd = new ClassHistogramDCmd(NULL, false);
 460   if (dcmd != NULL) {
 461     DCmdMark mark(dcmd);
 462     return dcmd->_dcmdparser.num_arguments();
 463   } else {
 464     return 0;
 465   }
 466 }
 467 
 468 #define DEFAULT_COLUMNS "InstBytes,KlassBytes,CpAll,annotations,MethodCount,Bytecodes,MethodAll,ROAll,RWAll,Total"
 469 ClassStatsDCmd::ClassStatsDCmd(outputStream* output, bool heap) :
 470                                        DCmdWithParser(output, heap),
 471   _csv("-csv", "Print in CSV (comma-separated values) format for spreadsheets",
 472        "BOOLEAN", false, "false"),
 473   _all("-all", "Show all columns",
 474        "BOOLEAN", false, "false"),
 475   _help("-help", "Show meaning of all the columns",
 476        "BOOLEAN", false, "false"),
 477   _columns("columns", "Comma-separated list of all the columns to show. "
 478            "If not specified, the following columns are shown: " DEFAULT_COLUMNS,
 479            "STRING", false) {
 480   _dcmdparser.add_dcmd_option(&_all);
 481   _dcmdparser.add_dcmd_option(&_csv);
 482   _dcmdparser.add_dcmd_option(&_help);
 483   _dcmdparser.add_dcmd_argument(&_columns);
 484 }
 485 
 486 void ClassStatsDCmd::execute(DCmdSource source, TRAPS) {
 487   if (!UnlockDiagnosticVMOptions) {
 488     output()->print_cr("GC.class_stats command requires -XX:+UnlockDiagnosticVMOptions");
 489     return;
 490   }
 491 
 492   VM_GC_HeapInspection heapop(output(),
 493                               true /* request_full_gc */);
 494   heapop.set_csv_format(_csv.value());
 495   heapop.set_print_help(_help.value());
 496   heapop.set_print_class_stats(true);
 497   if (_all.value()) {
 498     if (_columns.has_value()) {
 499       output()->print_cr("Cannot specify -all and individual columns at the same time");
 500       return;
 501     } else {
 502       heapop.set_columns(NULL);
 503     }
 504   } else {
 505     if (_columns.has_value()) {
 506       heapop.set_columns(_columns.value());
 507     } else {
 508       heapop.set_columns(DEFAULT_COLUMNS);
 509     }
 510   }
 511   VMThread::execute(&heapop);
 512 }
 513 
 514 int ClassStatsDCmd::num_arguments() {
 515   ResourceMark rm;
 516   ClassStatsDCmd* dcmd = new ClassStatsDCmd(NULL, false);
 517   if (dcmd != NULL) {
 518     DCmdMark mark(dcmd);
 519     return dcmd->_dcmdparser.num_arguments();
 520   } else {
 521     return 0;
 522   }
 523 }
 524 #endif // INCLUDE_SERVICES
 525 
 526 ThreadDumpDCmd::ThreadDumpDCmd(outputStream* output, bool heap) :
 527                                DCmdWithParser(output, heap),
 528   _locks("-l", "print java.util.concurrent locks", "BOOLEAN", false, "false") {
 529   _dcmdparser.add_dcmd_option(&_locks);
 530 }
 531 
 532 void ThreadDumpDCmd::execute(DCmdSource source, TRAPS) {
 533   // thread stacks
 534   VM_PrintThreads op1(output(), _locks.value());
 535   VMThread::execute(&op1);
 536 
 537   // JNI global handles
 538   VM_PrintJNI op2(output());
 539   VMThread::execute(&op2);
 540 
 541   // Deadlock detection
 542   VM_FindDeadlocks op3(output());
 543   VMThread::execute(&op3);
 544 }
 545 
 546 int ThreadDumpDCmd::num_arguments() {
 547   ResourceMark rm;
 548   ThreadDumpDCmd* dcmd = new ThreadDumpDCmd(NULL, false);
 549   if (dcmd != NULL) {
 550     DCmdMark mark(dcmd);
 551     return dcmd->_dcmdparser.num_arguments();
 552   } else {
 553     return 0;
 554   }
 555 }
 556 
 557 // Enhanced JMX Agent support
 558 
 559 JMXStartRemoteDCmd::JMXStartRemoteDCmd(outputStream *output, bool heap_allocated) :
 560 
 561   DCmdWithParser(output, heap_allocated),
 562 
 563   _config_file
 564   ("config.file",
 565    "set com.sun.management.config.file", "STRING", false),
 566 
 567   _jmxremote_port
 568   ("jmxremote.port",
 569    "set com.sun.management.jmxremote.port", "STRING", false),
 570 
 571   _jmxremote_rmi_port
 572   ("jmxremote.rmi.port",
 573    "set com.sun.management.jmxremote.rmi.port", "STRING", false),
 574 
 575   _jmxremote_ssl
 576   ("jmxremote.ssl",
 577    "set com.sun.management.jmxremote.ssl", "STRING", false),
 578 
 579   _jmxremote_registry_ssl
 580   ("jmxremote.registry.ssl",
 581    "set com.sun.management.jmxremote.registry.ssl", "STRING", false),
 582 
 583   _jmxremote_authenticate
 584   ("jmxremote.authenticate",
 585    "set com.sun.management.jmxremote.authenticate", "STRING", false),
 586 
 587   _jmxremote_password_file
 588   ("jmxremote.password.file",
 589    "set com.sun.management.jmxremote.password.file", "STRING", false),
 590 
 591   _jmxremote_access_file
 592   ("jmxremote.access.file",
 593    "set com.sun.management.jmxremote.access.file", "STRING", false),
 594 
 595   _jmxremote_login_config
 596   ("jmxremote.login.config",
 597    "set com.sun.management.jmxremote.login.config", "STRING", false),
 598 
 599   _jmxremote_ssl_enabled_cipher_suites
 600   ("jmxremote.ssl.enabled.cipher.suites",
 601    "set com.sun.management.jmxremote.ssl.enabled.cipher.suite", "STRING", false),
 602 
 603   _jmxremote_ssl_enabled_protocols
 604   ("jmxremote.ssl.enabled.protocols",
 605    "set com.sun.management.jmxremote.ssl.enabled.protocols", "STRING", false),
 606 
 607   _jmxremote_ssl_need_client_auth
 608   ("jmxremote.ssl.need.client.auth",
 609    "set com.sun.management.jmxremote.need.client.auth", "STRING", false),
 610 
 611   _jmxremote_ssl_config_file
 612   ("jmxremote.ssl.config.file",
 613    "set com.sun.management.jmxremote.ssl_config_file", "STRING", false),
 614 
 615 // JDP Protocol support
 616   _jmxremote_autodiscovery
 617   ("jmxremote.autodiscovery",
 618    "set com.sun.management.jmxremote.autodiscovery", "STRING", false),
 619 
 620    _jdp_port
 621   ("jdp.port",
 622    "set com.sun.management.jdp.port", "INT", false),
 623 
 624    _jdp_address
 625   ("jdp.address",
 626    "set com.sun.management.jdp.address", "STRING", false),
 627 
 628    _jdp_source_addr
 629   ("jdp.source_addr",
 630    "set com.sun.management.jdp.source_addr", "STRING", false),
 631 
 632    _jdp_ttl
 633   ("jdp.ttl",
 634    "set com.sun.management.jdp.ttl", "INT", false),
 635 
 636    _jdp_pause
 637   ("jdp.pause",
 638    "set com.sun.management.jdp.pause", "INT", false),
 639 
 640    _jdp_name
 641   ("jdp.name",
 642    "set com.sun.management.jdp.name", "STRING", false)
 643 
 644   {
 645     _dcmdparser.add_dcmd_option(&_config_file);
 646     _dcmdparser.add_dcmd_option(&_jmxremote_port);
 647     _dcmdparser.add_dcmd_option(&_jmxremote_rmi_port);
 648     _dcmdparser.add_dcmd_option(&_jmxremote_ssl);
 649     _dcmdparser.add_dcmd_option(&_jmxremote_registry_ssl);
 650     _dcmdparser.add_dcmd_option(&_jmxremote_authenticate);
 651     _dcmdparser.add_dcmd_option(&_jmxremote_password_file);
 652     _dcmdparser.add_dcmd_option(&_jmxremote_access_file);
 653     _dcmdparser.add_dcmd_option(&_jmxremote_login_config);
 654     _dcmdparser.add_dcmd_option(&_jmxremote_ssl_enabled_cipher_suites);
 655     _dcmdparser.add_dcmd_option(&_jmxremote_ssl_enabled_protocols);
 656     _dcmdparser.add_dcmd_option(&_jmxremote_ssl_need_client_auth);
 657     _dcmdparser.add_dcmd_option(&_jmxremote_ssl_config_file);
 658     _dcmdparser.add_dcmd_option(&_jmxremote_autodiscovery);
 659     _dcmdparser.add_dcmd_option(&_jdp_port);
 660     _dcmdparser.add_dcmd_option(&_jdp_address);
 661     _dcmdparser.add_dcmd_option(&_jdp_source_addr);
 662     _dcmdparser.add_dcmd_option(&_jdp_ttl);
 663     _dcmdparser.add_dcmd_option(&_jdp_pause);
 664     _dcmdparser.add_dcmd_option(&_jdp_name);
 665 }
 666 
 667 
 668 int JMXStartRemoteDCmd::num_arguments() {
 669   ResourceMark rm;
 670   JMXStartRemoteDCmd* dcmd = new JMXStartRemoteDCmd(NULL, false);
 671   if (dcmd != NULL) {
 672     DCmdMark mark(dcmd);
 673     return dcmd->_dcmdparser.num_arguments();
 674   } else {
 675     return 0;
 676   }
 677 }
 678 
 679 
 680 void JMXStartRemoteDCmd::execute(DCmdSource source, TRAPS) {
 681     ResourceMark rm(THREAD);
 682     HandleMark hm(THREAD);
 683 
 684     // Load and initialize the sun.management.Agent class
 685     // invoke startRemoteManagementAgent(string) method to start
 686     // the remote management server.
 687     // throw java.lang.NoSuchMethodError if the method doesn't exist
 688 
 689     Handle loader = Handle(THREAD, SystemDictionary::java_system_loader());
 690     Klass* k = SystemDictionary::resolve_or_fail(vmSymbols::sun_management_Agent(), loader, Handle(), true, CHECK);
 691     instanceKlassHandle ik (THREAD, k);
 692 
 693     JavaValue result(T_VOID);
 694 
 695     // Pass all command line arguments to java as key=value,...
 696     // All checks are done on java side
 697 
 698     int len = 0;
 699     stringStream options;
 700     char comma[2] = {0,0};
 701 
 702     // Leave default values on Agent.class side and pass only
 703     // agruments explicitly set by user. All arguments passed
 704     // to jcmd override properties with the same name set by
 705     // command line with -D or by managmenent.properties
 706     // file.
 707 #define PUT_OPTION(a) \
 708     do { \
 709         if ( (a).is_set() ){ \
 710             if ( *((a).type()) == 'I' ) { \
 711                 options.print("%scom.sun.management.%s=" JLONG_FORMAT, comma, (a).name(), (jlong)((a).value())); \
 712             } else { \
 713                 options.print("%scom.sun.management.%s=%s", comma, (a).name(), (char*)((a).value())); \
 714             } \
 715             comma[0] = ','; \
 716         }\
 717     } while(0);
 718 
 719 
 720     PUT_OPTION(_config_file);
 721     PUT_OPTION(_jmxremote_port);
 722     PUT_OPTION(_jmxremote_rmi_port);
 723     PUT_OPTION(_jmxremote_ssl);
 724     PUT_OPTION(_jmxremote_registry_ssl);
 725     PUT_OPTION(_jmxremote_authenticate);
 726     PUT_OPTION(_jmxremote_password_file);
 727     PUT_OPTION(_jmxremote_access_file);
 728     PUT_OPTION(_jmxremote_login_config);
 729     PUT_OPTION(_jmxremote_ssl_enabled_cipher_suites);
 730     PUT_OPTION(_jmxremote_ssl_enabled_protocols);
 731     PUT_OPTION(_jmxremote_ssl_need_client_auth);
 732     PUT_OPTION(_jmxremote_ssl_config_file);
 733     PUT_OPTION(_jmxremote_autodiscovery);
 734     PUT_OPTION(_jdp_port);
 735     PUT_OPTION(_jdp_address);
 736     PUT_OPTION(_jdp_source_addr);
 737     PUT_OPTION(_jdp_ttl);
 738     PUT_OPTION(_jdp_pause);
 739     PUT_OPTION(_jdp_name);
 740 
 741 #undef PUT_OPTION
 742 
 743     Handle str = java_lang_String::create_from_str(options.as_string(), CHECK);
 744     JavaCalls::call_static(&result, ik, vmSymbols::startRemoteAgent_name(), vmSymbols::string_void_signature(), str, CHECK);
 745 }
 746 
 747 JMXStartLocalDCmd::JMXStartLocalDCmd(outputStream *output, bool heap_allocated) :
 748   DCmd(output, heap_allocated) {
 749   // do nothing
 750 }
 751 
 752 void JMXStartLocalDCmd::execute(DCmdSource source, TRAPS) {
 753     ResourceMark rm(THREAD);
 754     HandleMark hm(THREAD);
 755 
 756     // Load and initialize the sun.management.Agent class
 757     // invoke startLocalManagementAgent(void) method to start
 758     // the local management server
 759     // throw java.lang.NoSuchMethodError if method doesn't exist
 760 
 761     Handle loader = Handle(THREAD, SystemDictionary::java_system_loader());
 762     Klass* k = SystemDictionary::resolve_or_fail(vmSymbols::sun_management_Agent(), loader, Handle(), true, CHECK);
 763     instanceKlassHandle ik (THREAD, k);
 764 
 765     JavaValue result(T_VOID);
 766     JavaCalls::call_static(&result, ik, vmSymbols::startLocalAgent_name(), vmSymbols::void_method_signature(), CHECK);
 767 }
 768 
 769 void JMXStopRemoteDCmd::execute(DCmdSource source, TRAPS) {
 770     ResourceMark rm(THREAD);
 771     HandleMark hm(THREAD);
 772 
 773     // Load and initialize the sun.management.Agent class
 774     // invoke stopRemoteManagementAgent method to stop the
 775     // management server
 776     // throw java.lang.NoSuchMethodError if method doesn't exist
 777 
 778     Handle loader = Handle(THREAD, SystemDictionary::java_system_loader());
 779     Klass* k = SystemDictionary::resolve_or_fail(vmSymbols::sun_management_Agent(), loader, Handle(), true, CHECK);
 780     instanceKlassHandle ik (THREAD, k);
 781 
 782     JavaValue result(T_VOID);
 783     JavaCalls::call_static(&result, ik, vmSymbols::stopRemoteAgent_name(), vmSymbols::void_method_signature(), CHECK);
 784 }
 785 
 786 JMXStatusDCmd::JMXStatusDCmd(outputStream *output, bool heap_allocated) :
 787   DCmd(output, heap_allocated) {
 788   // do nothing
 789 }
 790 
 791 void JMXStatusDCmd::execute(DCmdSource source, TRAPS) {
 792   ResourceMark rm(THREAD);
 793   HandleMark hm(THREAD);
 794 
 795   // Load and initialize the sun.management.Agent class
 796   // invoke getManagementAgentStatus() method to generate the status info
 797   // throw java.lang.NoSuchMethodError if method doesn't exist
 798 
 799   Handle loader = Handle(THREAD, SystemDictionary::java_system_loader());
 800   Klass* k = SystemDictionary::resolve_or_fail(vmSymbols::sun_management_Agent(), loader, Handle(), true, CHECK);
 801   instanceKlassHandle ik (THREAD, k);
 802 
 803   JavaValue result(T_OBJECT);
 804   JavaCalls::call_static(&result, ik, vmSymbols::getAgentStatus_name(), vmSymbols::void_string_signature(), CHECK);
 805 
 806   jvalue* jv = (jvalue*) result.get_value_addr();
 807   oop str = (oop) jv->l;
 808   if (str != NULL) {
 809       char* out = java_lang_String::as_utf8_string(str);
 810       if (out) {
 811           output()->print_cr("%s", out);
 812           return;
 813       }
 814   }
 815   output()->print_cr("Error obtaining management agent status");
 816 }
 817 
 818 VMDynamicLibrariesDCmd::VMDynamicLibrariesDCmd(outputStream *output, bool heap_allocated) :
 819   DCmd(output, heap_allocated) {
 820   // do nothing
 821 }
 822 
 823 void VMDynamicLibrariesDCmd::execute(DCmdSource source, TRAPS) {
 824   os::print_dll_info(output());
 825   output()->cr();
 826 }
 827 
 828 void RotateGCLogDCmd::execute(DCmdSource source, TRAPS) {
 829   if (UseGCLogFileRotation) {
 830     VM_RotateGCLog rotateop(output());
 831     VMThread::execute(&rotateop);
 832   } else {
 833     output()->print_cr("Target VM does not support GC log file rotation.");
 834   }
 835 }
 836 
 837 void CompileQueueDCmd::execute(DCmdSource source, TRAPS) {
 838   VM_PrintCompileQueue printCompileQueueOp(output());
 839   VMThread::execute(&printCompileQueueOp);
 840 }
 841 
 842 void CodeListDCmd::execute(DCmdSource source, TRAPS) {
 843   VM_PrintCodeList printCodeListOp(output());
 844   VMThread::execute(&printCodeListOp);
 845 }
 846 
 847 void CodeCacheDCmd::execute(DCmdSource source, TRAPS) {
 848   VM_PrintCodeCache printCodeCacheOp(output());
 849   VMThread::execute(&printCodeCacheOp);
 850 }
 851 
 852 void CompilerDirectivesPrintDCmd::execute(DCmdSource source, TRAPS) {
 853   DirectivesStack::print(output());
 854 }
 855 
 856 CompilerDirectivesAddDCmd::CompilerDirectivesAddDCmd(outputStream* output, bool heap) :
 857                            DCmdWithParser(output, heap),
 858   _filename("filename","Name of the directives file", "STRING",true) {
 859   _dcmdparser.add_dcmd_argument(&_filename);
 860 }
 861 
 862 void CompilerDirectivesAddDCmd::execute(DCmdSource source, TRAPS) {
 863   DirectivesParser::parse_from_file(_filename.value(), output());
 864 }
 865 
 866 int CompilerDirectivesAddDCmd::num_arguments() {
 867   ResourceMark rm;
 868   CompilerDirectivesAddDCmd* dcmd = new CompilerDirectivesAddDCmd(NULL, false);
 869   if (dcmd != NULL) {
 870     DCmdMark mark(dcmd);
 871     return dcmd->_dcmdparser.num_arguments();
 872   } else {
 873     return 0;
 874   }
 875 }
 876 
 877 void CompilerDirectivesRemoveDCmd::execute(DCmdSource source, TRAPS) {
 878   DirectivesStack::pop();
 879 }
 880 
 881 void CompilerDirectivesClearDCmd::execute(DCmdSource source, TRAPS) {
 882   DirectivesStack::clear();
 883 }
 884 #if INCLUDE_SERVICES
 885 ClassHierarchyDCmd::ClassHierarchyDCmd(outputStream* output, bool heap) :
 886                                        DCmdWithParser(output, heap),
 887   _print_interfaces("-i", "Inherited interfaces should be printed.", "BOOLEAN", false, "false"),
 888   _print_subclasses("-s", "If a classname is specified, print its subclasses. "
 889                     "Otherwise only its superclasses are printed.", "BOOLEAN", false, "false"),
 890   _classname("classname", "Name of class whose hierarchy should be printed. "
 891              "If not specified, all class hierarchies are printed.",
 892              "STRING", false) {
 893   _dcmdparser.add_dcmd_option(&_print_interfaces);
 894   _dcmdparser.add_dcmd_option(&_print_subclasses);
 895   _dcmdparser.add_dcmd_argument(&_classname);
 896 }
 897 
 898 void ClassHierarchyDCmd::execute(DCmdSource source, TRAPS) {
 899   VM_PrintClassHierarchy printClassHierarchyOp(output(), _print_interfaces.value(),
 900                                                _print_subclasses.value(), _classname.value());
 901   VMThread::execute(&printClassHierarchyOp);
 902 }
 903 
 904 int ClassHierarchyDCmd::num_arguments() {
 905   ResourceMark rm;
 906   ClassHierarchyDCmd* dcmd = new ClassHierarchyDCmd(NULL, false);
 907   if (dcmd != NULL) {
 908     DCmdMark mark(dcmd);
 909     return dcmd->_dcmdparser.num_arguments();
 910   } else {
 911     return 0;
 912   }
 913 }
 914 
 915 #endif
 916 
 917 class VM_DumpTouchedMethods : public VM_Operation {
 918 private:
 919   outputStream* _out;
 920 public:
 921   VM_DumpTouchedMethods(outputStream* out) {
 922     _out = out;
 923   }
 924 
 925   virtual VMOp_Type type() const { return VMOp_DumpTouchedMethods; }
 926 
 927   virtual void doit() {
 928     Method::print_touched_methods(_out);
 929   }
 930 };
 931 
 932 TouchedMethodsDCmd::TouchedMethodsDCmd(outputStream* output, bool heap) :
 933                                        DCmdWithParser(output, heap)
 934 {}
 935 
 936 void TouchedMethodsDCmd::execute(DCmdSource source, TRAPS) {
 937   if (!UnlockDiagnosticVMOptions) {
 938     output()->print_cr("VM.touched_methods command requires -XX:+UnlockDiagnosticVMOptions");
 939     return;
 940   }
 941   VM_DumpTouchedMethods dumper(output());
 942   VMThread::execute(&dumper);
 943 }
 944 
 945 int TouchedMethodsDCmd::num_arguments() {
 946   return 0;
 947 }
--- EOF ---