1 /*
   2  * Copyright (c) 2005, 2011, 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/javaClasses.hpp"
  27 #include "classfile/systemDictionary.hpp"
  28 #include "gc_implementation/shared/vmGCOperations.hpp"
  29 #include "memory/resourceArea.hpp"
  30 #include "prims/jvmtiExport.hpp"
  31 #include "runtime/arguments.hpp"
  32 #include "runtime/globals.hpp"
  33 #include "runtime/java.hpp"
  34 #include "runtime/javaCalls.hpp"
  35 #include "runtime/os.hpp"
  36 #include "services/attachListener.hpp"
  37 #include "services/heapDumper.hpp"

  38 
  39 volatile bool AttachListener::_initialized;
  40 
  41 // Implementation of "properties" command.
  42 //
  43 // Invokes sun.misc.VMSupport.serializePropertiesToByteArray to serialize
  44 // the system properties into a byte array.
  45 
  46 static klassOop load_and_initialize_klass(Symbol* sh, TRAPS) {
  47   klassOop k = SystemDictionary::resolve_or_fail(sh, true, CHECK_NULL);
  48   instanceKlassHandle ik (THREAD, k);
  49   if (ik->should_be_initialized()) {
  50     ik->initialize(CHECK_NULL);
  51   }
  52   return ik();
  53 }
  54 
  55 static jint get_properties(AttachOperation* op, outputStream* out, Symbol* serializePropertiesMethod) {
  56   Thread* THREAD = Thread::current();
  57   HandleMark hm;
  58 
  59   // load sun.misc.VMSupport
  60   Symbol* klass = vmSymbols::sun_misc_VMSupport();
  61   klassOop k = load_and_initialize_klass(klass, THREAD);
  62   if (HAS_PENDING_EXCEPTION) {
  63     java_lang_Throwable::print(PENDING_EXCEPTION, out);
  64     CLEAR_PENDING_EXCEPTION;
  65     return JNI_ERR;
  66   }
  67   instanceKlassHandle ik(THREAD, k);
  68 
  69   // invoke the serializePropertiesToByteArray method
  70   JavaValue result(T_OBJECT);
  71   JavaCallArguments args;
  72 
  73 
  74   Symbol* signature = vmSymbols::serializePropertiesToByteArray_signature();
  75   JavaCalls::call_static(&result,
  76                            ik,
  77                            serializePropertiesMethod,
  78                            signature,
  79                            &args,
  80                            THREAD);
  81   if (HAS_PENDING_EXCEPTION) {
  82     java_lang_Throwable::print(PENDING_EXCEPTION, out);
  83     CLEAR_PENDING_EXCEPTION;
  84     return JNI_ERR;
  85   }
  86 
  87   // The result should be a [B
  88   oop res = (oop)result.get_jobject();
  89   assert(res->is_typeArray(), "just checking");
  90   assert(typeArrayKlass::cast(res->klass())->element_type() == T_BYTE, "just checking");
  91 
  92   // copy the bytes to the output stream
  93   typeArrayOop ba = typeArrayOop(res);
  94   jbyte* addr = typeArrayOop(res)->byte_at_addr(0);
  95   out->print_raw((const char*)addr, ba->length());
  96 
  97   return JNI_OK;
  98 }
  99 
 100 // Implementation of "properties" command.
 101 static jint get_system_properties(AttachOperation* op, outputStream* out) {
 102   return get_properties(op, out, vmSymbols::serializePropertiesToByteArray_name());
 103 }
 104 
 105 // Implementation of "agent_properties" command.
 106 static jint get_agent_properties(AttachOperation* op, outputStream* out) {
 107   return get_properties(op, out, vmSymbols::serializeAgentPropertiesToByteArray_name());
 108 }
 109 
 110 // Implementation of "datadump" command.
 111 //
 112 // Raises a SIGBREAK signal so that VM dump threads, does deadlock detection,
 113 // etc. In theory this command should only post a DataDumpRequest to any
 114 // JVMTI environment that has enabled this event. However it's useful to
 115 // trigger the SIGBREAK handler.
 116 
 117 static jint data_dump(AttachOperation* op, outputStream* out) {
 118   if (!ReduceSignalUsage) {
 119     AttachListener::pd_data_dump();
 120   } else {
 121     if (JvmtiExport::should_post_data_dump()) {
 122       JvmtiExport::post_data_dump();
 123     }
 124   }
 125   return JNI_OK;
 126 }
 127 
 128 // Implementation of "threaddump" command - essentially a remote ctrl-break
 129 //
 130 static jint thread_dump(AttachOperation* op, outputStream* out) {
 131   bool print_concurrent_locks = false;
 132   if (op->arg(0) != NULL && strcmp(op->arg(0), "-l") == 0) {
 133     print_concurrent_locks = true;
 134   }
 135 
 136   // thread stacks
 137   VM_PrintThreads op1(out, print_concurrent_locks);
 138   VMThread::execute(&op1);
 139 
 140   // JNI global handles
 141   VM_PrintJNI op2(out);
 142   VMThread::execute(&op2);
 143 
 144   // Deadlock detection
 145   VM_FindDeadlocks op3(out);
 146   VMThread::execute(&op3);
 147 
 148   return JNI_OK;
 149 }
 150 





















 151 #ifndef SERVICES_KERNEL   // Heap dumping not supported
 152 // Implementation of "dumpheap" command.
 153 //
 154 // Input arguments :-
 155 //   arg0: Name of the dump file
 156 //   arg1: "-live" or "-all"
 157 jint dump_heap(AttachOperation* op, outputStream* out) {
 158   const char* path = op->arg(0);
 159   if (path == NULL || path[0] == '\0') {
 160     out->print_cr("No dump file specified");
 161   } else {
 162     bool live_objects_only = true;   // default is true to retain the behavior before this change is made
 163     const char* arg1 = op->arg(1);
 164     if (arg1 != NULL && (strlen(arg1) > 0)) {
 165       if (strcmp(arg1, "-all") != 0 && strcmp(arg1, "-live") != 0) {
 166         out->print_cr("Invalid argument to dumpheap operation: %s", arg1);
 167         return JNI_ERR;
 168       }
 169       live_objects_only = strcmp(arg1, "-live") == 0;
 170     }
 171 
 172     // Request a full GC before heap dump if live_objects_only = true
 173     // This helps reduces the amount of unreachable objects in the dump
 174     // and makes it easier to browse.
 175     HeapDumper dumper(live_objects_only /* request GC */);
 176     int res = dumper.dump(op->arg(0));
 177     if (res == 0) {
 178       out->print_cr("Heap dump file created");
 179     } else {
 180       // heap dump failed
 181       ResourceMark rm;
 182       char* error = dumper.error_as_C_string();
 183       if (error == NULL) {
 184         out->print_cr("Dump failed - reason unknown");
 185       } else {
 186         out->print_cr("%s", error);
 187       }
 188     }
 189   }
 190   return JNI_OK;
 191 }
 192 #endif // SERVICES_KERNEL
 193 
 194 // Implementation of "inspectheap" command
 195 //
 196 // Input arguments :-
 197 //   arg0: "-live" or "-all"
 198 static jint heap_inspection(AttachOperation* op, outputStream* out) {
 199   bool live_objects_only = true;   // default is true to retain the behavior before this change is made
 200   const char* arg0 = op->arg(0);
 201   if (arg0 != NULL && (strlen(arg0) > 0)) {
 202     if (strcmp(arg0, "-all") != 0 && strcmp(arg0, "-live") != 0) {
 203       out->print_cr("Invalid argument to inspectheap operation: %s", arg0);
 204       return JNI_ERR;
 205     }
 206     live_objects_only = strcmp(arg0, "-live") == 0;
 207   }
 208   VM_GC_HeapInspection heapop(out, live_objects_only /* request full gc */, true /* need_prologue */);
 209   VMThread::execute(&heapop);
 210   return JNI_OK;
 211 }
 212 
 213 // set a boolean global flag using value from AttachOperation
 214 static jint set_bool_flag(const char* name, AttachOperation* op, outputStream* out) {
 215   bool value = true;
 216   const char* arg1;
 217   if ((arg1 = op->arg(1)) != NULL) {
 218     int tmp;
 219     int n = sscanf(arg1, "%d", &tmp);
 220     if (n != 1) {
 221       out->print_cr("flag value must be a boolean (1 or 0)");
 222       return JNI_ERR;
 223     }
 224     value = (tmp != 0);
 225   }
 226   bool res = CommandLineFlags::boolAtPut((char*)name, &value, ATTACH_ON_DEMAND);
 227   if (! res) {
 228     out->print_cr("setting flag %s failed", name);
 229   }
 230   return res? JNI_OK : JNI_ERR;
 231 }
 232 
 233 // set a intx global flag using value from AttachOperation
 234 static jint set_intx_flag(const char* name, AttachOperation* op, outputStream* out) {
 235   intx value;
 236   const char* arg1;
 237   if ((arg1 = op->arg(1)) != NULL) {
 238     int n = sscanf(arg1, INTX_FORMAT, &value);
 239     if (n != 1) {
 240       out->print_cr("flag value must be an integer");
 241       return JNI_ERR;
 242     }
 243   }
 244   bool res = CommandLineFlags::intxAtPut((char*)name, &value, ATTACH_ON_DEMAND);
 245   if (! res) {
 246     out->print_cr("setting flag %s failed", name);
 247   }
 248 
 249   return res? JNI_OK : JNI_ERR;
 250 }
 251 
 252 // set a uintx global flag using value from AttachOperation
 253 static jint set_uintx_flag(const char* name, AttachOperation* op, outputStream* out) {
 254   uintx value;
 255   const char* arg1;
 256   if ((arg1 = op->arg(1)) != NULL) {
 257     int n = sscanf(arg1, UINTX_FORMAT, &value);
 258     if (n != 1) {
 259       out->print_cr("flag value must be an unsigned integer");
 260       return JNI_ERR;
 261     }
 262   }
 263   bool res = CommandLineFlags::uintxAtPut((char*)name, &value, ATTACH_ON_DEMAND);
 264   if (! res) {
 265     out->print_cr("setting flag %s failed", name);
 266   }
 267 
 268   return res? JNI_OK : JNI_ERR;
 269 }
 270 
 271 // set a uint64_t global flag using value from AttachOperation
 272 static jint set_uint64_t_flag(const char* name, AttachOperation* op, outputStream* out) {
 273   uint64_t value;
 274   const char* arg1;
 275   if ((arg1 = op->arg(1)) != NULL) {
 276     int n = sscanf(arg1, UINT64_FORMAT, &value);
 277     if (n != 1) {
 278       out->print_cr("flag value must be an unsigned 64-bit integer");
 279       return JNI_ERR;
 280     }
 281   }
 282   bool res = CommandLineFlags::uint64_tAtPut((char*)name, &value, ATTACH_ON_DEMAND);
 283   if (! res) {
 284     out->print_cr("setting flag %s failed", name);
 285   }
 286 
 287   return res? JNI_OK : JNI_ERR;
 288 }
 289 
 290 // set a string global flag using value from AttachOperation
 291 static jint set_ccstr_flag(const char* name, AttachOperation* op, outputStream* out) {
 292   const char* value;
 293   if ((value = op->arg(1)) == NULL) {
 294     out->print_cr("flag value must be a string");
 295     return JNI_ERR;
 296   }
 297   bool res = CommandLineFlags::ccstrAtPut((char*)name, &value, ATTACH_ON_DEMAND);
 298   if (res) {
 299     FREE_C_HEAP_ARRAY(char, value);
 300   } else {
 301     out->print_cr("setting flag %s failed", name);
 302   }
 303 
 304   return res? JNI_OK : JNI_ERR;
 305 }
 306 
 307 // Implementation of "setflag" command
 308 static jint set_flag(AttachOperation* op, outputStream* out) {
 309 
 310   const char* name = NULL;
 311   if ((name = op->arg(0)) == NULL) {
 312     out->print_cr("flag name is missing");
 313     return JNI_ERR;
 314   }
 315 
 316   Flag* f = Flag::find_flag((char*)name, strlen(name));
 317   if (f && f->is_external() && f->is_writeable()) {
 318     if (f->is_bool()) {
 319       return set_bool_flag(name, op, out);
 320     } else if (f->is_intx()) {
 321       return set_intx_flag(name, op, out);
 322     } else if (f->is_uintx()) {
 323       return set_uintx_flag(name, op, out);
 324     } else if (f->is_uint64_t()) {
 325       return set_uint64_t_flag(name, op, out);
 326     } else if (f->is_ccstr()) {
 327       return set_ccstr_flag(name, op, out);
 328     } else {
 329       ShouldNotReachHere();
 330       return JNI_ERR;
 331     }
 332   } else {
 333     return AttachListener::pd_set_flag(op, out);
 334   }
 335 }
 336 
 337 // Implementation of "printflag" command
 338 static jint print_flag(AttachOperation* op, outputStream* out) {
 339   const char* name = NULL;
 340   if ((name = op->arg(0)) == NULL) {
 341     out->print_cr("flag name is missing");
 342     return JNI_ERR;
 343   }
 344   Flag* f = Flag::find_flag((char*)name, strlen(name));
 345   if (f) {
 346     f->print_as_flag(out);
 347     out->print_cr("");
 348   } else {
 349     out->print_cr("no such flag '%s'", name);
 350   }
 351   return JNI_OK;
 352 }
 353 
 354 // Table to map operation names to functions.
 355 
 356 // names must be of length <= AttachOperation::name_length_max
 357 static AttachOperationFunctionInfo funcs[] = {
 358   { "agentProperties",  get_agent_properties },
 359   { "datadump",         data_dump },
 360 #ifndef SERVICES_KERNEL
 361   { "dumpheap",         dump_heap },
 362 #endif  // SERVICES_KERNEL
 363   { "load",             JvmtiExport::load_agent_library },
 364   { "properties",       get_system_properties },
 365   { "threaddump",       thread_dump },
 366   { "inspectheap",      heap_inspection },
 367   { "setflag",          set_flag },
 368   { "printflag",        print_flag },

 369   { NULL,               NULL }
 370 };
 371 
 372 
 373 
 374 // The Attach Listener threads services a queue. It dequeues an operation
 375 // from the queue, examines the operation name (command), and dispatches
 376 // to the corresponding function to perform the operation.
 377 
 378 static void attach_listener_thread_entry(JavaThread* thread, TRAPS) {
 379   os::set_priority(thread, NearMaxPriority);
 380 
 381   if (AttachListener::pd_init() != 0) {
 382     return;
 383   }
 384   AttachListener::set_initialized();
 385 
 386   for (;;) {
 387     AttachOperation* op = AttachListener::dequeue();
 388     if (op == NULL) {
 389       return;   // dequeue failed or shutdown
 390     }
 391 
 392     ResourceMark rm;
 393     bufferedStream st;
 394     jint res = JNI_OK;
 395 
 396     // handle special detachall operation
 397     if (strcmp(op->name(), AttachOperation::detachall_operation_name()) == 0) {
 398       AttachListener::detachall();
 399     } else {
 400       // find the function to dispatch too
 401       AttachOperationFunctionInfo* info = NULL;
 402       for (int i=0; funcs[i].name != NULL; i++) {
 403         const char* name = funcs[i].name;
 404         assert(strlen(name) <= AttachOperation::name_length_max, "operation <= name_length_max");
 405         if (strcmp(op->name(), name) == 0) {
 406           info = &(funcs[i]);
 407           break;
 408         }
 409       }
 410 
 411       // check for platform dependent attach operation
 412       if (info == NULL) {
 413         info = AttachListener::pd_find_operation(op->name());
 414       }
 415 
 416       if (info != NULL) {
 417         // dispatch to the function that implements this operation
 418         res = (info->func)(op, &st);
 419       } else {
 420         st.print("Operation %s not recognized!", op->name());
 421         res = JNI_ERR;
 422       }
 423     }
 424 
 425     // operation complete - send result and output to client
 426     op->complete(res, &st);
 427   }
 428 }
 429 
 430 // Starts the Attach Listener thread
 431 void AttachListener::init() {
 432   EXCEPTION_MARK;
 433   klassOop k = SystemDictionary::resolve_or_fail(vmSymbols::java_lang_Thread(), true, CHECK);
 434   instanceKlassHandle klass (THREAD, k);
 435   instanceHandle thread_oop = klass->allocate_instance_handle(CHECK);
 436 
 437   const char thread_name[] = "Attach Listener";
 438   Handle string = java_lang_String::create_from_str(thread_name, CHECK);
 439 
 440   // Initialize thread_oop to put it into the system threadGroup
 441   Handle thread_group (THREAD, Universe::system_thread_group());
 442   JavaValue result(T_VOID);
 443   JavaCalls::call_special(&result, thread_oop,
 444                        klass,
 445                        vmSymbols::object_initializer_name(),
 446                        vmSymbols::threadgroup_string_void_signature(),
 447                        thread_group,
 448                        string,
 449                        CHECK);
 450 
 451   KlassHandle group(THREAD, SystemDictionary::ThreadGroup_klass());
 452   JavaCalls::call_special(&result,
 453                         thread_group,
 454                         group,
 455                         vmSymbols::add_method_name(),
 456                         vmSymbols::thread_void_signature(),
 457                         thread_oop,             // ARG 1
 458                         CHECK);
 459 
 460   { MutexLocker mu(Threads_lock);
 461     JavaThread* listener_thread = new JavaThread(&attach_listener_thread_entry);
 462 
 463     // Check that thread and osthread were created
 464     if (listener_thread == NULL || listener_thread->osthread() == NULL) {
 465       vm_exit_during_initialization("java.lang.OutOfMemoryError",
 466                                     "unable to create new native thread");
 467     }
 468 
 469     java_lang_Thread::set_thread(thread_oop(), listener_thread);
 470     java_lang_Thread::set_daemon(thread_oop());
 471 
 472     listener_thread->set_threadObj(thread_oop());
 473     Threads::add(listener_thread);
 474     Thread::start(listener_thread);
 475   }
 476 }
 477 
 478 // Performs clean-up tasks on platforms where we can detect that the last
 479 // client has detached
 480 void AttachListener::detachall() {
 481   // call the platform dependent clean-up
 482   pd_detachall();
 483 }
--- EOF ---