1 /*
   2  * Copyright (c) 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/systemDictionary.hpp"
  27 #include "classfile/vmSymbols.hpp"
  28 #include "oops/oop.inline.hpp"
  29 #include "runtime/interfaceSupport.hpp"
  30 #include "runtime/java.hpp"
  31 #include "runtime/javaCalls.hpp"
  32 #include "runtime/mutex.hpp"
  33 #include "runtime/mutexLocker.hpp"
  34 #include "services/gcNotifier.hpp"
  35 #include "services/management.hpp"
  36 #include "services/memoryService.hpp"
  37 #include "memoryManager.hpp"
  38 #include "memory/oopFactory.hpp"
  39 
  40 GCNotificationRequest *GCNotifier::first_request = NULL;
  41 GCNotificationRequest *GCNotifier::last_request = NULL;
  42 
  43 void GCNotifier::pushNotification(GCMemoryManager *mgr, const char *action, const char *cause) {
  44   // Make a copy of the last GC statistics
  45   // GC may occur between now and the creation of the notification
  46   int num_pools = MemoryService::num_memory_pools();
  47   GCStatInfo* stat = new GCStatInfo(num_pools);
  48   mgr->get_last_gc_stat(stat);
  49   GCNotificationRequest *request = new GCNotificationRequest(os::javaTimeMillis(),mgr,action,cause,stat);
  50   addRequest(request);
  51  }
  52 
  53 void GCNotifier::addRequest(GCNotificationRequest *request) {
  54   MutexLockerEx ml(Service_lock, Mutex::_no_safepoint_check_flag);
  55   if(first_request == NULL) {
  56     first_request = request;
  57   } else {
  58     last_request->next = request;
  59   }
  60   last_request = request;
  61   Service_lock->notify_all();
  62 }
  63 
  64 GCNotificationRequest *GCNotifier::getRequest() {
  65   MutexLockerEx ml(Service_lock, Mutex::_no_safepoint_check_flag);
  66   GCNotificationRequest *request = first_request;
  67   if(first_request != NULL) {
  68     first_request = first_request->next;
  69   }
  70   return request;
  71 }
  72 
  73 bool GCNotifier::has_event() {
  74   return first_request != NULL;
  75 }
  76 
  77 static Handle getGcInfoBuilder(GCMemoryManager *gcManager,TRAPS) {
  78 
  79   klassOop k = Management::sun_management_GarbageCollectorImpl_klass(CHECK_NH);
  80   instanceKlassHandle gcMBeanKlass (THREAD, k);
  81 
  82   instanceOop i = gcManager->get_memory_manager_instance(THREAD);
  83   instanceHandle ih(THREAD, i);
  84 
  85   JavaValue result(T_OBJECT);
  86   JavaCallArguments args(ih);
  87 
  88   JavaCalls::call_virtual(&result,
  89                           gcMBeanKlass,
  90                           vmSymbols::getGcInfoBuilder_name(),
  91                           vmSymbols::getGcInfoBuilder_signature(),
  92                           &args,
  93                           CHECK_NH);
  94   return Handle(THREAD,(oop)result.get_jobject());
  95 
  96 }
  97 
  98 static Handle createGcInfo(GCMemoryManager *gcManager, GCStatInfo *gcStatInfo,TRAPS) {
  99 
 100   // Fill the arrays of MemoryUsage objects with before and after GC
 101   // per pool memory usage
 102 
 103   klassOop mu_klass = Management::java_lang_management_MemoryUsage_klass(CHECK_NH);
 104   instanceKlassHandle mu_kh(THREAD, mu_klass);
 105 
 106   // The array allocations should use a handle containing mu_klass
 107   // as the first allocation could trigger a GC, causing the actual
 108   // klass oop to move, and leaving mu_klass pointing to the old
 109   // location.
 110   objArrayOop bu = oopFactory::new_objArray(mu_kh(), MemoryService::num_memory_pools(), CHECK_NH);
 111   objArrayHandle usage_before_gc_ah(THREAD, bu);
 112   objArrayOop au = oopFactory::new_objArray(mu_kh(), MemoryService::num_memory_pools(), CHECK_NH);
 113   objArrayHandle usage_after_gc_ah(THREAD, au);
 114 
 115   for (int i = 0; i < MemoryService::num_memory_pools(); i++) {
 116     Handle before_usage = MemoryService::create_MemoryUsage_obj(gcStatInfo->before_gc_usage_for_pool(i), CHECK_NH);
 117     Handle after_usage;
 118 
 119     MemoryUsage u = gcStatInfo->after_gc_usage_for_pool(i);
 120     if (u.max_size() == 0 && u.used() > 0) {
 121       // If max size == 0, this pool is a survivor space.
 122       // Set max size = -1 since the pools will be swapped after GC.
 123       MemoryUsage usage(u.init_size(), u.used(), u.committed(), (size_t)-1);
 124       after_usage = MemoryService::create_MemoryUsage_obj(usage, CHECK_NH);
 125     } else {
 126         after_usage = MemoryService::create_MemoryUsage_obj(u, CHECK_NH);
 127     }
 128     usage_before_gc_ah->obj_at_put(i, before_usage());
 129     usage_after_gc_ah->obj_at_put(i, after_usage());
 130   }
 131 
 132   // Current implementation only has 1 attribute (number of GC threads)
 133   // The type is 'I'
 134   objArrayOop extra_args_array = oopFactory::new_objArray(SystemDictionary::Integer_klass(), 1, CHECK_NH);
 135   objArrayHandle extra_array (THREAD, extra_args_array);
 136   klassOop itKlass= SystemDictionary::Integer_klass();
 137   instanceKlassHandle intK(THREAD, itKlass);
 138 
 139   instanceHandle extra_arg_val = intK->allocate_instance_handle(CHECK_NH);
 140 
 141   {
 142     JavaValue res(T_VOID);
 143     JavaCallArguments argsInt;
 144     argsInt.push_oop(extra_arg_val);
 145     argsInt.push_int(gcManager->num_gc_threads());
 146 
 147     JavaCalls::call_special(&res,
 148                             intK,
 149                             vmSymbols::object_initializer_name(),
 150                             vmSymbols::int_void_signature(),
 151                             &argsInt,
 152                             CHECK_NH);
 153   }
 154   extra_array->obj_at_put(0,extra_arg_val());
 155 
 156   klassOop gcInfoklass = Management::com_sun_management_GcInfo_klass(CHECK_NH);
 157   instanceKlassHandle ik (THREAD,gcInfoklass);
 158 
 159   Handle gcInfo_instance = ik->allocate_instance_handle(CHECK_NH);
 160 
 161   JavaValue constructor_result(T_VOID);
 162   JavaCallArguments constructor_args(16);
 163   constructor_args.push_oop(gcInfo_instance);
 164   constructor_args.push_oop(getGcInfoBuilder(gcManager,THREAD));
 165   constructor_args.push_long(gcStatInfo->gc_index());
 166   constructor_args.push_long(gcStatInfo->start_time());
 167   constructor_args.push_long(gcStatInfo->end_time());
 168   constructor_args.push_oop(usage_before_gc_ah);
 169   constructor_args.push_oop(usage_after_gc_ah);
 170   constructor_args.push_oop(extra_array);
 171 
 172   JavaCalls::call_special(&constructor_result,
 173                           ik,
 174                           vmSymbols::object_initializer_name(),
 175                           vmSymbols::com_sun_management_GcInfo_constructor_signature(),
 176                           &constructor_args,
 177                           CHECK_NH);
 178 
 179   return Handle(gcInfo_instance());
 180 }
 181 
 182 void GCNotifier::sendNotification(TRAPS) {
 183   ResourceMark rm(THREAD);
 184   GCNotificationRequest *request = getRequest();
 185   if(request != NULL) {
 186     Handle objGcInfo = createGcInfo(request->gcManager,request->gcStatInfo,THREAD);
 187 
 188     Handle objName = java_lang_String::create_from_platform_dependent_str(request->gcManager->name(), CHECK);
 189     Handle objAction = java_lang_String::create_from_platform_dependent_str(request->gcAction, CHECK);
 190     Handle objCause = java_lang_String::create_from_platform_dependent_str(request->gcCause, CHECK);
 191 
 192     klassOop k = Management::sun_management_GarbageCollectorImpl_klass(CHECK);
 193     instanceKlassHandle gc_mbean_klass (THREAD, k);
 194 
 195     instanceOop gc_mbean = request->gcManager->get_memory_manager_instance(THREAD);
 196     instanceHandle gc_mbean_h(THREAD, gc_mbean);
 197     if (!gc_mbean_h->is_a(k)) {
 198       THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(),
 199                 "This GCMemoryManager doesn't have a GarbageCollectorMXBean");
 200     }
 201 
 202     JavaValue result(T_VOID);
 203     JavaCallArguments args(gc_mbean_h);
 204     args.push_long(request->timestamp);
 205     args.push_oop(objName);
 206     args.push_oop(objAction);
 207     args.push_oop(objCause);
 208     args.push_oop(objGcInfo);
 209 
 210     JavaCalls::call_virtual(&result,
 211                             gc_mbean_klass,
 212                             vmSymbols::createGCNotification_name(),
 213                             vmSymbols::createGCNotification_signature(),
 214                             &args,
 215                             CHECK);
 216     if (HAS_PENDING_EXCEPTION) {
 217       CLEAR_PENDING_EXCEPTION;
 218     }
 219 
 220     delete request;
 221   }
 222 }
 223