1 /*
2 * Copyright (c) 2004, 2012, 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. Oracle designates this
8 * particular file as subject to the "Classpath" exception as provided
9 * by Oracle in the LICENSE file that accompanied this code.
10 *
11 * This code is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 * version 2 for more details (a copy is included in the LICENSE file that
15 * accompanied this code).
16 *
17 * You should have received a copy of the GNU General Public License version
18 * 2 along with this work; if not, write to the Free Software Foundation,
19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20 *
21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22 * or visit www.oracle.com if you need additional information or have any
23 * questions.
24 */
25
26 package sun.management;
27
28 import java.lang.management.MemoryUsage;
29 import java.lang.reflect.Method;
30 import java.lang.reflect.Field;
31 import java.util.Iterator;
32 import java.util.Map;
33 import java.util.HashMap;
34 import java.util.List;
35 import java.util.Collections;
36 import java.io.InvalidObjectException;
37 import javax.management.openmbean.CompositeType;
38 import javax.management.openmbean.CompositeData;
39 import javax.management.openmbean.CompositeDataSupport;
40 import javax.management.openmbean.TabularData;
41 import javax.management.openmbean.SimpleType;
42 import javax.management.openmbean.OpenType;
43 import javax.management.openmbean.OpenDataException;
44 import com.sun.management.GcInfo;
45 import com.sun.management.GarbageCollectionNotificationInfo;
46 import java.security.AccessController;
47 import java.security.PrivilegedAction;
48
49 /**
50 * A CompositeData for GcInfo for the local management support.
51 * This class avoids the performance penalty paid to the
52 * construction of a CompositeData use in the local case.
53 */
54 public class GcInfoCompositeData extends LazyCompositeData {
55 private final GcInfo info;
56 private final GcInfoBuilder builder;
57 private final Object[] gcExtItemValues;
58
59 public GcInfoCompositeData(GcInfo info,
60 GcInfoBuilder builder,
61 Object[] gcExtItemValues) {
62 this.info = info;
63 this.builder = builder;
64 this.gcExtItemValues = gcExtItemValues;
65 }
66
67 public GcInfo getGcInfo() {
68 return info;
69 }
70
71 public static CompositeData toCompositeData(final GcInfo info) {
72 final GcInfoBuilder builder = AccessController.doPrivileged (new PrivilegedAction<GcInfoBuilder>() {
73 public GcInfoBuilder run() {
74 try {
75 Class cl = Class.forName("com.sun.management.GcInfo");
76 Field f = cl.getDeclaredField("builder");
77 f.setAccessible(true);
78 return (GcInfoBuilder)f.get(info);
79 } catch(ClassNotFoundException | NoSuchFieldException | IllegalAccessException e) {
80 return null;
81 }
82 }
83 });
84 final Object[] extAttr = AccessController.doPrivileged (new PrivilegedAction<Object[]>() {
85 public Object[] run() {
86 try {
87 Class cl = Class.forName("com.sun.management.GcInfo");
88 Field f = cl.getDeclaredField("extAttributes");
89 f.setAccessible(true);
90 return (Object[])f.get(info);
91 } catch(ClassNotFoundException | NoSuchFieldException | IllegalAccessException e) {
92 return null;
93 }
94 }
95 });
96 GcInfoCompositeData gcicd =
97 new GcInfoCompositeData(info,builder,extAttr);
98 return gcicd.getCompositeData();
99 }
100
101 protected CompositeData getCompositeData() {
102 // CONTENTS OF THIS ARRAY MUST BE SYNCHRONIZED WITH
103 // baseGcInfoItemNames!
104 final Object[] baseGcInfoItemValues;
105
106 try {
107 baseGcInfoItemValues = new Object[] {
108 new Long(info.getId()),
109 new Long(info.getStartTime()),
110 new Long(info.getEndTime()),
111 new Long(info.getDuration()),
112 memoryUsageMapType.toOpenTypeData(info.getMemoryUsageBeforeGc()),
113 memoryUsageMapType.toOpenTypeData(info.getMemoryUsageAfterGc()),
114 };
115 } catch (OpenDataException e) {
116 // Should never reach here
117 throw new AssertionError(e);
118 }
119
120 // Get the item values for the extension attributes
121 final int gcExtItemCount = builder.getGcExtItemCount();
122 if (gcExtItemCount == 0 &&
123 gcExtItemValues != null && gcExtItemValues.length != 0) {
124 throw new AssertionError("Unexpected Gc Extension Item Values");
125 }
126
127 if (gcExtItemCount > 0 && (gcExtItemValues == null ||
128 gcExtItemCount != gcExtItemValues.length)) {
129 throw new AssertionError("Unmatched Gc Extension Item Values");
130 }
131
132 Object[] values = new Object[baseGcInfoItemValues.length +
133 gcExtItemCount];
134 System.arraycopy(baseGcInfoItemValues, 0, values, 0,
135 baseGcInfoItemValues.length);
136
137 if (gcExtItemCount > 0) {
138 System.arraycopy(gcExtItemValues, 0, values,
139 baseGcInfoItemValues.length, gcExtItemCount);
140 }
141
142 try {
143 return new CompositeDataSupport(builder.getGcInfoCompositeType(),
144 builder.getItemNames(),
145 values);
146 } catch (OpenDataException e) {
147 // Should never reach here
148 throw new AssertionError(e);
149 }
150 }
151
152 private static final String ID = "id";
153 private static final String START_TIME = "startTime";
154 private static final String END_TIME = "endTime";
155 private static final String DURATION = "duration";
156 private static final String MEMORY_USAGE_BEFORE_GC = "memoryUsageBeforeGc";
157 private static final String MEMORY_USAGE_AFTER_GC = "memoryUsageAfterGc";
158
159 private static final String[] baseGcInfoItemNames = {
160 ID,
161 START_TIME,
162 END_TIME,
163 DURATION,
164 MEMORY_USAGE_BEFORE_GC,
165 MEMORY_USAGE_AFTER_GC,
166 };
167
168
169 private static MappedMXBeanType memoryUsageMapType;
170 static {
171 try {
172 Method m = GcInfo.class.getMethod("getMemoryUsageBeforeGc");
173 memoryUsageMapType =
174 MappedMXBeanType.getMappedType(m.getGenericReturnType());
175 } catch (NoSuchMethodException | OpenDataException e) {
176 // Should never reach here
177 throw new AssertionError(e);
178 }
179 }
180
181 static String[] getBaseGcInfoItemNames() {
182 return baseGcInfoItemNames;
183 }
184
185 private static OpenType[] baseGcInfoItemTypes = null;
186 static synchronized OpenType[] getBaseGcInfoItemTypes() {
187 if (baseGcInfoItemTypes == null) {
188 OpenType<?> memoryUsageOpenType = memoryUsageMapType.getOpenType();
189 baseGcInfoItemTypes = new OpenType<?>[] {
190 SimpleType.LONG,
191 SimpleType.LONG,
192 SimpleType.LONG,
193 SimpleType.LONG,
194
195 memoryUsageOpenType,
196 memoryUsageOpenType,
197 };
198 }
199 return baseGcInfoItemTypes;
200 }
201
202 public static long getId(CompositeData cd) {
203 return getLong(cd, ID);
204 }
205 public static long getStartTime(CompositeData cd) {
206 return getLong(cd, START_TIME);
207 }
208 public static long getEndTime(CompositeData cd) {
209 return getLong(cd, END_TIME);
210 }
211
212 public static Map<String, MemoryUsage>
213 getMemoryUsageBeforeGc(CompositeData cd) {
214 try {
215 TabularData td = (TabularData) cd.get(MEMORY_USAGE_BEFORE_GC);
216 return cast(memoryUsageMapType.toJavaTypeData(td));
217 } catch (InvalidObjectException | OpenDataException e) {
218 // Should never reach here
219 throw new AssertionError(e);
220 }
221 }
222
223 @SuppressWarnings("unchecked")
224 public static Map<String, MemoryUsage> cast(Object x) {
225 return (Map<String, MemoryUsage>) x;
226 }
227 public static Map<String, MemoryUsage>
228 getMemoryUsageAfterGc(CompositeData cd) {
229 try {
230 TabularData td = (TabularData) cd.get(MEMORY_USAGE_AFTER_GC);
231 //return (Map<String,MemoryUsage>)
232 return cast(memoryUsageMapType.toJavaTypeData(td));
233 } catch (InvalidObjectException | OpenDataException e) {
234 // Should never reach here
235 throw new AssertionError(e);
236 }
237 }
238
239 /**
240 * Returns true if the input CompositeData has the expected
241 * CompositeType (i.e. contain all attributes with expected
242 * names and types). Otherwise, return false.
243 */
244 public static void validateCompositeData(CompositeData cd) {
245 if (cd == null) {
246 throw new NullPointerException("Null CompositeData");
247 }
248
249 if (!isTypeMatched(getBaseGcInfoCompositeType(),
250 cd.getCompositeType())) {
251 throw new IllegalArgumentException(
252 "Unexpected composite type for GcInfo");
253 }
254 }
255
256 // This is only used for validation.
257 private static CompositeType baseGcInfoCompositeType = null;
258 static synchronized CompositeType getBaseGcInfoCompositeType() {
259 if (baseGcInfoCompositeType == null) {
260 try {
261 baseGcInfoCompositeType =
262 new CompositeType("sun.management.BaseGcInfoCompositeType",
263 "CompositeType for Base GcInfo",
264 getBaseGcInfoItemNames(),
265 getBaseGcInfoItemNames(),
266 getBaseGcInfoItemTypes());
267 } catch (OpenDataException e) {
268 // shouldn't reach here
269 throw Util.newException(e);
270 }
271 }
272 return baseGcInfoCompositeType;
273 }
274
275 private static final long serialVersionUID = -5716428894085882742L;
276 }