rev 50556 : [mq]: jcmd-cleanups

   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 #include "precompiled.hpp"
  26 #include "jvm.h"
  27 #include "memory/oopFactory.hpp"
  28 #include "memory/resourceArea.hpp"
  29 #include "oops/oop.inline.hpp"
  30 #include "runtime/handles.inline.hpp"
  31 #include "runtime/javaCalls.hpp"
  32 #include "runtime/mutexLocker.hpp"
  33 #include "services/diagnosticArgument.hpp"
  34 #include "services/diagnosticFramework.hpp"
  35 #include "services/management.hpp"
  36 
  37 CmdLine::CmdLine(const char* line, size_t len, bool no_command_name)
  38   : _cmd(NULL)
  39   , _cmd_len(0)
  40   , _args(NULL)
  41   , _args_len(0)
  42 {
  43   assert(line != NULL, "Command line string should not be NULL");
  44   const char* line_end;
  45   const char* cmd_end;
  46 
  47   _cmd = line;
  48   line_end = &line[len];
  49 
  50   // Skip whitespace in the beginning of the line.
  51   while (_cmd < line_end && isspace((int) _cmd[0])) {
  52     _cmd++;
  53   }
  54   cmd_end = _cmd;
  55 
  56   if (no_command_name) {
  57     _cmd = NULL;
  58     _cmd_len = 0;
  59   } else {
  60     // Look for end of the command name
  61     while (cmd_end < line_end && !isspace((int) cmd_end[0])) {
  62       cmd_end++;
  63     }
  64     _cmd_len = cmd_end - _cmd;
  65   }
  66   _args = cmd_end;
  67   _args_len = line_end - _args;
  68 }
  69 
  70 bool DCmdArgIter::next(TRAPS) {
  71   if (_len == 0) return false;
  72   // skipping delimiters
  73   while (_cursor < _len - 1 && _buffer[_cursor] == _delim) {
  74     _cursor++;
  75   }
  76   // handling end of command line
  77   if (_cursor == _len - 1 && _buffer[_cursor] == _delim) {
  78     _key_addr = &_buffer[_cursor];
  79     _key_len = 0;
  80     _value_addr = &_buffer[_cursor];
  81     _value_len = 0;
  82     return false;
  83   }
  84   // extracting first item, argument or option name
  85   _key_addr = &_buffer[_cursor];
  86   bool arg_had_quotes = false;
  87   while (_cursor <= _len - 1 && _buffer[_cursor] != '=' && _buffer[_cursor] != _delim) {
  88     // argument can be surrounded by single or double quotes
  89     if (_buffer[_cursor] == '\"' || _buffer[_cursor] == '\'') {
  90       _key_addr++;
  91       char quote = _buffer[_cursor];
  92       arg_had_quotes = true;
  93       while (_cursor < _len - 1) {
  94         _cursor++;
  95         if (_buffer[_cursor] == quote && _buffer[_cursor - 1] != '\\') {
  96           break;
  97         }
  98       }
  99       if (_buffer[_cursor] != quote) {
 100         THROW_MSG_(vmSymbols::java_lang_IllegalArgumentException(),
 101                 "Format error in diagnostic command arguments", false);
 102       }
 103       break;
 104     }
 105     _cursor++;
 106   }
 107   _key_len = &_buffer[_cursor] - _key_addr;
 108   if (arg_had_quotes) {
 109     // if the argument was quoted, we need to step past the last quote here
 110     _cursor++;
 111   }
 112   // check if the argument has the <key>=<value> format
 113   if (_cursor <= _len -1 && _buffer[_cursor] == '=') {
 114     _cursor++;
 115     _value_addr = &_buffer[_cursor];
 116     bool value_had_quotes = false;
 117     // extract the value
 118     while (_cursor <= _len - 1 && _buffer[_cursor] != _delim) {
 119       // value can be surrounded by simple or double quotes
 120       if (_buffer[_cursor] == '\"' || _buffer[_cursor] == '\'') {
 121         _value_addr++;
 122         char quote = _buffer[_cursor];
 123         value_had_quotes = true;
 124         while (_cursor < _len - 1) {
 125           _cursor++;
 126           if (_buffer[_cursor] == quote && _buffer[_cursor - 1] != '\\') {
 127             break;
 128           }
 129         }
 130         if (_buffer[_cursor] != quote) {
 131           THROW_MSG_(vmSymbols::java_lang_IllegalArgumentException(),
 132                   "Format error in diagnostic command arguments", false);
 133         }
 134         break;
 135       }
 136       _cursor++;
 137     }
 138     _value_len = &_buffer[_cursor] - _value_addr;
 139     if (value_had_quotes) {
 140       // if the value was quoted, we need to step past the last quote here
 141       _cursor++;
 142     }
 143   } else {
 144     _value_addr = NULL;
 145     _value_len = 0;
 146   }
 147   return _key_len != 0;
 148 }
 149 
 150 bool DCmdInfo::by_name(void* cmd_name, DCmdInfo* info) {
 151   if (info == NULL) return false;
 152   return strcmp((const char*)cmd_name, info->name()) == 0;
 153 }
 154 
 155 void DCmdParser::add_dcmd_option(GenDCmdArgument* arg) {
 156   assert(arg != NULL, "Sanity");
 157   if (_options == NULL) {
 158     _options = arg;
 159   } else {
 160     GenDCmdArgument* o = _options;
 161     while (o->next() != NULL) {
 162       o = o->next();
 163     }
 164     o->set_next(arg);
 165   }
 166   arg->set_next(NULL);
 167   Thread* THREAD = Thread::current();
 168   arg->init_value(THREAD);
 169   if (HAS_PENDING_EXCEPTION) {
 170     fatal("Initialization must be successful");
 171   }
 172 }
 173 
 174 void DCmdParser::add_dcmd_argument(GenDCmdArgument* arg) {
 175   assert(arg != NULL, "Sanity");
 176   if (_arguments_list == NULL) {
 177     _arguments_list = arg;
 178   } else {
 179     GenDCmdArgument* a = _arguments_list;
 180     while (a->next() != NULL) {
 181       a = a->next();
 182     }
 183     a->set_next(arg);
 184   }
 185   arg->set_next(NULL);
 186   Thread* THREAD = Thread::current();
 187   arg->init_value(THREAD);
 188   if (HAS_PENDING_EXCEPTION) {
 189     fatal("Initialization must be successful");
 190   }
 191 }
 192 
 193 void DCmdParser::parse(CmdLine* line, char delim, TRAPS) {
 194   GenDCmdArgument* next_argument = _arguments_list;
 195   DCmdArgIter iter(line->args_addr(), line->args_len(), delim);
 196   bool cont = iter.next(CHECK);
 197   while (cont) {
 198     GenDCmdArgument* arg = lookup_dcmd_option(iter.key_addr(),
 199             iter.key_length());
 200     if (arg != NULL) {
 201       arg->read_value(iter.value_addr(), iter.value_length(), CHECK);
 202     } else {
 203       if (next_argument != NULL) {
 204         arg = next_argument;
 205         arg->read_value(iter.key_addr(), iter.key_length(), CHECK);
 206         next_argument = next_argument->next();
 207       } else {
 208         const size_t buflen    = 120;
 209         const size_t argbuflen = 30;
 210         char buf[buflen];
 211         char argbuf[argbuflen];
 212         size_t len = MIN2<size_t>(iter.key_length(), argbuflen - 1);
 213 
 214         strncpy(argbuf, iter.key_addr(), len);
 215         argbuf[len] = '\0';
 216         jio_snprintf(buf, buflen - 1, "Unknown argument '%s' in diagnostic command.", argbuf);
 217 
 218         THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(), buf);
 219       }
 220     }
 221     cont = iter.next(CHECK);
 222   }
 223   check(CHECK);
 224 }
 225 
 226 GenDCmdArgument* DCmdParser::lookup_dcmd_option(const char* name, size_t len) {
 227   GenDCmdArgument* arg = _options;
 228   while (arg != NULL) {
 229     if (strlen(arg->name()) == len &&
 230       strncmp(name, arg->name(), len) == 0) {
 231       return arg;
 232     }
 233     arg = arg->next();
 234   }
 235   return NULL;
 236 }
 237 
 238 void DCmdParser::check(TRAPS) {
 239   const size_t buflen = 256;
 240   char buf[buflen];
 241   GenDCmdArgument* arg = _arguments_list;
 242   while (arg != NULL) {
 243     if (arg->is_mandatory() && !arg->has_value()) {
 244       jio_snprintf(buf, buflen - 1, "The argument '%s' is mandatory.", arg->name());
 245       THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(), buf);
 246     }
 247     arg = arg->next();
 248   }
 249   arg = _options;
 250   while (arg != NULL) {
 251     if (arg->is_mandatory() && !arg->has_value()) {
 252       jio_snprintf(buf, buflen - 1, "The option '%s' is mandatory.", arg->name());
 253       THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(), buf);
 254     }
 255     arg = arg->next();
 256   }
 257 }
 258 
 259 void DCmdParser::print_help(outputStream* out, const char* cmd_name) const {
 260   out->print("Syntax : %s %s", cmd_name, _options == NULL ? "" : "[options]");
 261   GenDCmdArgument* arg = _arguments_list;
 262   while (arg != NULL) {
 263     if (arg->is_mandatory()) {
 264       out->print(" <%s>", arg->name());
 265     } else {
 266       out->print(" [<%s>]", arg->name());
 267     }
 268     arg = arg->next();
 269   }
 270   out->cr();
 271   if (_arguments_list != NULL) {
 272     out->print_cr("\nArguments:");
 273     arg = _arguments_list;
 274     while (arg != NULL) {
 275       out->print("\t%s : %s %s (%s, ", arg->name(),
 276                  arg->is_mandatory() ? "" : "[optional]",
 277                  arg->description(), arg->type());
 278       if (arg->has_default()) {
 279         out->print("%s", arg->default_string());
 280       } else {
 281         out->print("no default value");
 282       }
 283       out->print_cr(")");
 284       arg = arg->next();
 285     }
 286   }
 287   if (_options != NULL) {
 288     out->print_cr("\nOptions: (options must be specified using the <key> or <key>=<value> syntax)");
 289     arg = _options;
 290     while (arg != NULL) {
 291       out->print("\t%s : %s %s (%s, ", arg->name(),
 292                  arg->is_mandatory() ? "" : "[optional]",
 293                  arg->description(), arg->type());
 294       if (arg->has_default()) {
 295         out->print("%s", arg->default_string());
 296       } else {
 297         out->print("no default value");
 298       }
 299       out->print_cr(")");
 300       arg = arg->next();
 301     }
 302   }
 303 }
 304 
 305 void DCmdParser::reset(TRAPS) {
 306   GenDCmdArgument* arg = _arguments_list;
 307   while (arg != NULL) {
 308     arg->reset(CHECK);
 309     arg = arg->next();
 310   }
 311   arg = _options;
 312   while (arg != NULL) {
 313     arg->reset(CHECK);
 314     arg = arg->next();
 315   }
 316 }
 317 
 318 void DCmdParser::cleanup() {
 319   GenDCmdArgument* arg = _arguments_list;
 320   while (arg != NULL) {
 321     arg->cleanup();
 322     arg = arg->next();
 323   }
 324   arg = _options;
 325   while (arg != NULL) {
 326     arg->cleanup();
 327     arg = arg->next();
 328   }
 329 }
 330 
 331 int DCmdParser::num_arguments() const {
 332   GenDCmdArgument* arg = _arguments_list;
 333   int count = 0;
 334   while (arg != NULL) {
 335     count++;
 336     arg = arg->next();
 337   }
 338   arg = _options;
 339   while (arg != NULL) {
 340     count++;
 341     arg = arg->next();
 342   }
 343   return count;
 344 }
 345 
 346 GrowableArray<const char *>* DCmdParser::argument_name_array() const {
 347   int count = num_arguments();
 348   GrowableArray<const char *>* array = new GrowableArray<const char *>(count);
 349   GenDCmdArgument* arg = _arguments_list;
 350   while (arg != NULL) {
 351     array->append(arg->name());
 352     arg = arg->next();
 353   }
 354   arg = _options;
 355   while (arg != NULL) {
 356     array->append(arg->name());
 357     arg = arg->next();
 358   }
 359   return array;
 360 }
 361 
 362 GrowableArray<DCmdArgumentInfo*>* DCmdParser::argument_info_array() const {
 363   int count = num_arguments();
 364   GrowableArray<DCmdArgumentInfo*>* array = new GrowableArray<DCmdArgumentInfo *>(count);
 365   int idx = 0;
 366   GenDCmdArgument* arg = _arguments_list;
 367   while (arg != NULL) {
 368     array->append(new DCmdArgumentInfo(arg->name(), arg->description(),
 369                   arg->type(), arg->default_string(), arg->is_mandatory(),
 370                   false, arg->allow_multiple(), idx));
 371     idx++;
 372     arg = arg->next();
 373   }
 374   arg = _options;
 375   while (arg != NULL) {
 376     array->append(new DCmdArgumentInfo(arg->name(), arg->description(),
 377                   arg->type(), arg->default_string(), arg->is_mandatory(),
 378                   true, arg->allow_multiple()));
 379     arg = arg->next();
 380   }
 381   return array;
 382 }
 383 
 384 DCmdFactory* DCmdFactory::_DCmdFactoryList = NULL;
 385 bool DCmdFactory::_has_pending_jmx_notification = false;
 386 
 387 void DCmd::parse_and_execute(DCmdSource source, outputStream* out,
 388                              const char* cmdline, char delim, TRAPS) {
 389 
 390   if (cmdline == NULL) return; // Nothing to do!
 391   DCmdIter iter(cmdline, '\n');
 392 
 393   int count = 0;
 394   while (iter.has_next()) {
 395     if(source == DCmd_Source_MBean && count > 0) {
 396       // When diagnostic commands are invoked via JMX, each command line
 397       // must contains one and only one command because of the Permission
 398       // checks performed by the DiagnosticCommandMBean
 399       THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(),
 400               "Invalid syntax");
 401     }
 402     CmdLine line = iter.next();
 403     if (line.is_stop()) {
 404       break;
 405     }
 406     if (line.is_executable()) {
 407       ResourceMark rm;
 408       DCmd* command = DCmdFactory::create_local_DCmd(source, line, out, CHECK);
 409       assert(command != NULL, "command error must be handled before this line");
 410       DCmdMark mark(command);
 411       command->parse(&line, delim, CHECK);
 412       command->execute(source, CHECK);
 413     }
 414     count++;
 415   }
 416 }
 417 
 418 void DCmdWithParser::parse(CmdLine* line, char delim, TRAPS) {
 419   _dcmdparser.parse(line, delim, CHECK);
 420 }
 421 
 422 void DCmdWithParser::print_help(const char* name) const {
 423   _dcmdparser.print_help(output(), name);
 424 }
 425 
 426 void DCmdWithParser::reset(TRAPS) {
 427   _dcmdparser.reset(CHECK);
 428 }
 429 
 430 void DCmdWithParser::cleanup() {
 431   _dcmdparser.cleanup();
 432 }
 433 
 434 GrowableArray<const char*>* DCmdWithParser::argument_name_array() const {
 435   return _dcmdparser.argument_name_array();
 436 }
 437 
 438 GrowableArray<DCmdArgumentInfo*>* DCmdWithParser::argument_info_array() const {
 439   return _dcmdparser.argument_info_array();
 440 }
 441 
 442 void DCmdFactory::push_jmx_notification_request() {
 443   MutexLockerEx ml(Service_lock, Mutex::_no_safepoint_check_flag);
 444   _has_pending_jmx_notification = true;
 445   Service_lock->notify_all();
 446 }
 447 
 448 void DCmdFactory::send_notification(TRAPS) {
 449   DCmdFactory::send_notification_internal(THREAD);
 450   // Clearing pending exception to avoid premature termination of
 451   // the service thread
 452   if (HAS_PENDING_EXCEPTION) {
 453     CLEAR_PENDING_EXCEPTION;
 454   }
 455 }
 456 void DCmdFactory::send_notification_internal(TRAPS) {
 457   ResourceMark rm(THREAD);
 458   HandleMark hm(THREAD);
 459   bool notif = false;
 460   {
 461     MutexLockerEx ml(Service_lock, Mutex::_no_safepoint_check_flag);
 462     notif = _has_pending_jmx_notification;
 463     _has_pending_jmx_notification = false;
 464   }
 465   if (notif) {
 466 
 467     Klass* k = Management::com_sun_management_internal_DiagnosticCommandImpl_klass(CHECK);
 468     InstanceKlass* dcmd_mbean_klass = InstanceKlass::cast(k);
 469 
 470     JavaValue result(T_OBJECT);
 471     JavaCalls::call_static(&result,
 472             dcmd_mbean_klass,
 473             vmSymbols::getDiagnosticCommandMBean_name(),
 474             vmSymbols::getDiagnosticCommandMBean_signature(),
 475             CHECK);
 476 
 477     instanceOop m = (instanceOop) result.get_jobject();
 478     instanceHandle dcmd_mbean_h(THREAD, m);
 479 
 480     if (!dcmd_mbean_h->is_a(k)) {
 481       THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(),
 482               "DiagnosticCommandImpl.getDiagnosticCommandMBean didn't return a DiagnosticCommandMBean instance");
 483     }
 484 
 485     JavaValue result2(T_VOID);
 486     JavaCallArguments args2(dcmd_mbean_h);
 487 
 488     JavaCalls::call_virtual(&result2,
 489             dcmd_mbean_klass,
 490             vmSymbols::createDiagnosticFrameworkNotification_name(),
 491             vmSymbols::void_method_signature(),
 492             &args2,
 493             CHECK);
 494   }
 495 }
 496 
 497 Mutex* DCmdFactory::_dcmdFactory_lock = new Mutex(Mutex::leaf, "DCmdFactory", true, Monitor::_safepoint_check_never);
 498 bool DCmdFactory::_send_jmx_notification = false;
 499 
 500 DCmdFactory* DCmdFactory::factory(DCmdSource source, const char* name, size_t len) {
 501   MutexLockerEx ml(_dcmdFactory_lock, Mutex::_no_safepoint_check_flag);
 502   DCmdFactory* factory = _DCmdFactoryList;
 503   while (factory != NULL) {
 504     if (strlen(factory->name()) == len &&
 505         strncmp(name, factory->name(), len) == 0) {
 506       if(factory->export_flags() & source) {
 507         return factory;
 508       } else {
 509         return NULL;
 510       }
 511     }
 512     factory = factory->_next;
 513   }
 514   return NULL;
 515 }
 516 
 517 int DCmdFactory::register_DCmdFactory(DCmdFactory* factory) {
 518   MutexLockerEx ml(_dcmdFactory_lock, Mutex::_no_safepoint_check_flag);
 519   factory->_next = _DCmdFactoryList;
 520   _DCmdFactoryList = factory;
 521   if (_send_jmx_notification && !factory->_hidden
 522       && (factory->_export_flags & DCmd_Source_MBean)) {
 523     DCmdFactory::push_jmx_notification_request();
 524   }
 525   return 0; // Actually, there's no checks for duplicates














 526 }
 527 
 528 DCmd* DCmdFactory::create_local_DCmd(DCmdSource source, CmdLine &line,
 529                                      outputStream* out, TRAPS) {
 530   DCmdFactory* f = factory(source, line.cmd_addr(), line.cmd_len());
 531   if (f != NULL) {
 532     if (!f->is_enabled()) {
 533       THROW_MSG_NULL(vmSymbols::java_lang_IllegalArgumentException(),
 534                      f->disabled_message());
 535     }
 536     return f->create_resource_instance(out);
 537   }
 538   THROW_MSG_NULL(vmSymbols::java_lang_IllegalArgumentException(),
 539              "Unknown diagnostic command");
 540 }
 541 
 542 GrowableArray<const char*>* DCmdFactory::DCmd_list(DCmdSource source) {
 543   MutexLockerEx ml(_dcmdFactory_lock, Mutex::_no_safepoint_check_flag);
 544   GrowableArray<const char*>* array = new GrowableArray<const char*>();
 545   DCmdFactory* factory = _DCmdFactoryList;
 546   while (factory != NULL) {
 547     if (!factory->is_hidden() && (factory->export_flags() & source)) {
 548       array->append(factory->name());
 549     }
 550     factory = factory->next();
 551   }
 552   return array;
 553 }
 554 
 555 GrowableArray<DCmdInfo*>* DCmdFactory::DCmdInfo_list(DCmdSource source ) {
 556   MutexLockerEx ml(_dcmdFactory_lock, Mutex::_no_safepoint_check_flag);
 557   GrowableArray<DCmdInfo*>* array = new GrowableArray<DCmdInfo*>();
 558   DCmdFactory* factory = _DCmdFactoryList;
 559   while (factory != NULL) {
 560     if (!factory->is_hidden() && (factory->export_flags() & source)) {
 561       array->append(new DCmdInfo(factory->name(),
 562                     factory->description(), factory->impact(),
 563                     factory->permission(), factory->num_arguments(),
 564                     factory->is_enabled()));
 565     }
 566     factory = factory->next();
 567   }
 568   return array;
 569 }
--- EOF ---