Print this page
| Split |
Close |
| Expand all |
| Collapse all |
--- old/src/share/native/sun/management/VMManagementImpl.c
+++ new/src/share/native/sun/management/VMManagementImpl.c
1 1 /*
2 - * Copyright (c) 2003, 2011, Oracle and/or its affiliates. All rights reserved.
2 + * Copyright (c) 2003, 2013, Oracle and/or its affiliates. All rights reserved.
3 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 4 *
5 5 * This code is free software; you can redistribute it and/or modify it
6 6 * under the terms of the GNU General Public License version 2 only, as
7 7 * published by the Free Software Foundation. Oracle designates this
8 8 * particular file as subject to the "Classpath" exception as provided
9 9 * by Oracle in the LICENSE file that accompanied this code.
10 10 *
11 11 * This code is distributed in the hope that it will be useful, but WITHOUT
12 12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 14 * version 2 for more details (a copy is included in the LICENSE file that
15 15 * accompanied this code).
16 16 *
|
↓ open down ↓ |
4 lines elided |
↑ open up ↑ |
17 17 * You should have received a copy of the GNU General Public License version
18 18 * 2 along with this work; if not, write to the Free Software Foundation,
19 19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20 20 *
21 21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22 22 * or visit www.oracle.com if you need additional information or have any
23 23 * questions.
24 24 */
25 25
26 26 #include <jni.h>
27 +#include <stdlib.h>
27 28 #include "jvm.h"
28 29 #include "management.h"
29 30 #include "sun_management_VMManagementImpl.h"
30 31
31 32 #define MAX_VERSION_LEN 20
32 33
33 34 JNIEXPORT jstring JNICALL
34 35 Java_sun_management_VMManagementImpl_getVersion0
35 36 (JNIEnv *env, jclass dummy)
36 37 {
37 38 char buf[MAX_VERSION_LEN];
38 39 jstring version_string = NULL;
39 40
40 41 unsigned int major = ((unsigned int) jmm_version & 0x0FFF0000) >> 16;
41 42 unsigned int minor = ((unsigned int) jmm_version & 0xFF00) >> 8;
42 43
43 44 // for internal use
44 45 unsigned int micro = (unsigned int) jmm_version & 0xFF;
45 46
46 47 sprintf(buf, "%d.%d", major, minor);
47 48 version_string = (*env)->NewStringUTF(env, buf);
48 49 return version_string;
49 50 }
50 51
51 52 static void setStaticBooleanField
52 53 (JNIEnv* env, jclass cls, const char* name, jboolean value)
53 54 {
54 55 jfieldID fid;
55 56 fid = (*env)->GetStaticFieldID(env, cls, name, "Z");
56 57 if (fid != 0) {
57 58 (*env)->SetStaticBooleanField(env, cls, fid, value);
58 59 }
59 60 }
60 61
61 62 JNIEXPORT void JNICALL
62 63 Java_sun_management_VMManagementImpl_initOptionalSupportFields
63 64 (JNIEnv *env, jclass cls)
64 65 {
65 66 jmmOptionalSupport mos;
66 67 jint ret = jmm_interface->GetOptionalSupport(env, &mos);
67 68
68 69 jboolean value;
69 70
70 71 value = mos.isCompilationTimeMonitoringSupported;
71 72 setStaticBooleanField(env, cls, "compTimeMonitoringSupport", value);
72 73
73 74 value = mos.isThreadContentionMonitoringSupported;
74 75 setStaticBooleanField(env, cls, "threadContentionMonitoringSupport", value);
75 76
76 77 value = mos.isCurrentThreadCpuTimeSupported;
77 78 setStaticBooleanField(env, cls, "currentThreadCpuTimeSupport", value);
78 79
79 80 value = mos.isOtherThreadCpuTimeSupported;
80 81 setStaticBooleanField(env, cls, "otherThreadCpuTimeSupport", value);
81 82
82 83 value = mos.isBootClassPathSupported;
83 84 setStaticBooleanField(env, cls, "bootClassPathSupport", value);
84 85
85 86 if (jmm_version >= JMM_VERSION_1_1) {
86 87 value = mos.isObjectMonitorUsageSupported;
87 88 setStaticBooleanField(env, cls, "objectMonitorUsageSupport", value);
88 89
|
↓ open down ↓ |
52 lines elided |
↑ open up ↑ |
89 90 value = mos.isSynchronizerUsageSupported;
90 91 setStaticBooleanField(env, cls, "synchronizerUsageSupport", value);
91 92 } else {
92 93 setStaticBooleanField(env, cls, "objectMonitorUsageSupport", JNI_FALSE);
93 94 setStaticBooleanField(env, cls, "synchronizerUsageSupport", JNI_FALSE);
94 95 }
95 96
96 97 value = mos.isThreadAllocatedMemorySupported;
97 98 setStaticBooleanField(env, cls, "threadAllocatedMemorySupport", value);
98 99
100 + value = mos.isRemoteDiagnosticCommandsSupported;
101 + setStaticBooleanField(env, cls, "remoteDiagnosticCommandsSupport", value);
102 +
99 103 if ((jmm_version > JMM_VERSION_1_2) ||
100 104 (jmm_version == JMM_VERSION_1_2 && ((jmm_version&0xFF) >= 1))) {
101 105 setStaticBooleanField(env, cls, "gcNotificationSupport", JNI_TRUE);
102 106 } else {
103 107 setStaticBooleanField(env, cls, "gcNotificationSupport", JNI_FALSE);
104 108 }
105 109 }
106 110
107 111 JNIEXPORT jobjectArray JNICALL
108 112 Java_sun_management_VMManagementImpl_getVmArguments0
109 113 (JNIEnv *env, jobject dummy)
110 114 {
111 115 return jmm_interface->GetInputArgumentArray(env);
112 116 }
113 117
114 118 JNIEXPORT jlong JNICALL
115 119 Java_sun_management_VMManagementImpl_getTotalClassCount
116 120 (JNIEnv *env, jobject dummy)
117 121 {
118 122 /* JMM_CLASS_LOADED_COUNT is the total number of classes loaded */
119 123 jlong count = jmm_interface->GetLongAttribute(env, NULL,
120 124 JMM_CLASS_LOADED_COUNT);
121 125 return count;
122 126 }
123 127
124 128 JNIEXPORT jlong JNICALL
125 129 Java_sun_management_VMManagementImpl_getUnloadedClassCount
126 130 (JNIEnv *env, jobject dummy)
127 131 {
128 132 /* JMM_CLASS_UNLOADED_COUNT is the total number of classes unloaded */
129 133 jlong count = jmm_interface->GetLongAttribute(env, NULL,
130 134 JMM_CLASS_UNLOADED_COUNT);
131 135 return count;
132 136 }
133 137
134 138 JNIEXPORT jboolean JNICALL
135 139 Java_sun_management_VMManagementImpl_getVerboseGC
136 140 (JNIEnv *env, jobject dummy)
137 141 {
138 142 return jmm_interface->GetBoolAttribute(env, JMM_VERBOSE_GC);
139 143 }
140 144
141 145 JNIEXPORT jboolean JNICALL
142 146 Java_sun_management_VMManagementImpl_getVerboseClass
143 147 (JNIEnv *env, jobject dummy)
144 148 {
145 149 return jmm_interface->GetBoolAttribute(env, JMM_VERBOSE_CLASS);
146 150 }
147 151
148 152 JNIEXPORT jlong JNICALL
149 153 Java_sun_management_VMManagementImpl_getTotalThreadCount
150 154 (JNIEnv *env, jobject dummy)
151 155 {
152 156 return jmm_interface->GetLongAttribute(env, NULL,
153 157 JMM_THREAD_TOTAL_COUNT);
154 158 }
155 159
156 160 JNIEXPORT jint JNICALL
157 161 Java_sun_management_VMManagementImpl_getLiveThreadCount
158 162 (JNIEnv *env, jobject dummy)
159 163 {
160 164 jlong count = jmm_interface->GetLongAttribute(env, NULL,
161 165 JMM_THREAD_LIVE_COUNT);
162 166 return (jint) count;
163 167 }
164 168
165 169 JNIEXPORT jint JNICALL
166 170 Java_sun_management_VMManagementImpl_getPeakThreadCount
167 171 (JNIEnv *env, jobject dummy)
168 172 {
169 173 jlong count = jmm_interface->GetLongAttribute(env, NULL,
170 174 JMM_THREAD_PEAK_COUNT);
171 175 return (jint) count;
172 176 }
173 177
174 178 JNIEXPORT jint JNICALL
175 179 Java_sun_management_VMManagementImpl_getDaemonThreadCount
176 180 (JNIEnv *env, jobject dummy)
177 181 {
178 182 jlong count = jmm_interface->GetLongAttribute(env, NULL,
179 183 JMM_THREAD_DAEMON_COUNT);
180 184 return (jint) count;
181 185 }
182 186
183 187 JNIEXPORT jlong JNICALL
184 188 Java_sun_management_VMManagementImpl_getTotalCompileTime
185 189 (JNIEnv *env, jobject dummy)
186 190 {
187 191 return jmm_interface->GetLongAttribute(env, NULL,
188 192 JMM_COMPILE_TOTAL_TIME_MS);
189 193 }
190 194
191 195 JNIEXPORT jlong JNICALL
192 196 Java_sun_management_VMManagementImpl_getStartupTime
193 197 (JNIEnv *env, jobject dummy)
194 198 {
195 199 return jmm_interface->GetLongAttribute(env, NULL,
196 200 JMM_JVM_INIT_DONE_TIME_MS);
197 201 }
198 202
199 203 JNIEXPORT jboolean JNICALL
200 204 Java_sun_management_VMManagementImpl_isThreadContentionMonitoringEnabled
201 205 (JNIEnv *env, jobject dummy)
202 206 {
203 207 return jmm_interface->GetBoolAttribute(env,
204 208 JMM_THREAD_CONTENTION_MONITORING);
205 209 }
206 210
207 211 JNIEXPORT jboolean JNICALL
208 212 Java_sun_management_VMManagementImpl_isThreadCpuTimeEnabled
209 213 (JNIEnv *env, jobject dummy)
210 214 {
211 215 return jmm_interface->GetBoolAttribute(env, JMM_THREAD_CPU_TIME);
212 216 }
213 217
214 218 JNIEXPORT jboolean JNICALL
215 219 Java_sun_management_VMManagementImpl_isThreadAllocatedMemoryEnabled
216 220 (JNIEnv *env, jobject dummy)
217 221 {
218 222 return jmm_interface->GetBoolAttribute(env, JMM_THREAD_ALLOCATED_MEMORY);
219 223 }
220 224
221 225 JNIEXPORT jint JNICALL
222 226 Java_sun_management_VMManagementImpl_getProcessId
223 227 (JNIEnv *env, jobject dummy)
224 228 {
225 229 jlong pid = jmm_interface->GetLongAttribute(env, NULL,
226 230 JMM_OS_PROCESS_ID);
227 231 return (jint) pid;
228 232 }
229 233
230 234 JNIEXPORT jint JNICALL
231 235 Java_sun_management_VMManagementImpl_getAvailableProcessors
232 236 (JNIEnv *env, jobject dummy)
233 237 {
234 238 return JVM_ActiveProcessorCount();
235 239 }
236 240
237 241 JNIEXPORT jlong JNICALL
238 242 Java_sun_management_VMManagementImpl_getSafepointCount
239 243 (JNIEnv *env, jobject dummy)
240 244 {
241 245 return jmm_interface->GetLongAttribute(env, NULL,
242 246 JMM_SAFEPOINT_COUNT);
243 247 }
244 248
245 249 JNIEXPORT jlong JNICALL
246 250 Java_sun_management_VMManagementImpl_getTotalSafepointTime
247 251 (JNIEnv *env, jobject dummy)
248 252 {
249 253 return jmm_interface->GetLongAttribute(env, NULL,
250 254 JMM_TOTAL_STOPPED_TIME_MS);
251 255 }
252 256
253 257 JNIEXPORT jlong JNICALL
254 258 Java_sun_management_VMManagementImpl_getSafepointSyncTime
255 259 (JNIEnv *env, jobject dummy)
256 260 {
257 261 return jmm_interface->GetLongAttribute(env, NULL,
258 262 JMM_TOTAL_SAFEPOINTSYNC_TIME_MS);
259 263 }
260 264
261 265 JNIEXPORT jlong JNICALL
262 266 Java_sun_management_VMManagementImpl_getTotalApplicationNonStoppedTime
263 267 (JNIEnv *env, jobject dummy)
264 268 {
265 269 return jmm_interface->GetLongAttribute(env, NULL,
266 270 JMM_TOTAL_APP_TIME_MS);
267 271 }
268 272
269 273 JNIEXPORT jlong JNICALL
270 274 Java_sun_management_VMManagementImpl_getLoadedClassSize
271 275 (JNIEnv *env, jobject dummy)
272 276 {
273 277 return jmm_interface->GetLongAttribute(env, NULL,
274 278 JMM_CLASS_LOADED_BYTES);
275 279 }
276 280
277 281 JNIEXPORT jlong JNICALL
278 282 Java_sun_management_VMManagementImpl_getUnloadedClassSize
279 283 (JNIEnv *env, jobject dummy)
280 284 {
281 285 return jmm_interface->GetLongAttribute(env, NULL,
282 286 JMM_CLASS_UNLOADED_BYTES);
283 287 }
284 288 JNIEXPORT jlong JNICALL
285 289 Java_sun_management_VMManagementImpl_getClassLoadingTime
286 290 (JNIEnv *env, jobject dummy)
287 291 {
288 292 return jmm_interface->GetLongAttribute(env, NULL,
289 293 JMM_TOTAL_CLASSLOAD_TIME_MS);
290 294 }
291 295
292 296
293 297 JNIEXPORT jlong JNICALL
294 298 Java_sun_management_VMManagementImpl_getMethodDataSize
295 299 (JNIEnv *env, jobject dummy)
296 300 {
297 301 return jmm_interface->GetLongAttribute(env, NULL,
298 302 JMM_METHOD_DATA_SIZE_BYTES);
299 303 }
300 304
301 305 JNIEXPORT jlong JNICALL
302 306 Java_sun_management_VMManagementImpl_getInitializedClassCount
303 307 (JNIEnv *env, jobject dummy)
304 308 {
305 309 return jmm_interface->GetLongAttribute(env, NULL,
306 310 JMM_CLASS_INIT_TOTAL_COUNT);
307 311 }
308 312
309 313 JNIEXPORT jlong JNICALL
310 314 Java_sun_management_VMManagementImpl_getClassInitializationTime
311 315 (JNIEnv *env, jobject dummy)
312 316 {
313 317 return jmm_interface->GetLongAttribute(env, NULL,
314 318 JMM_CLASS_INIT_TOTAL_TIME_MS);
315 319 }
316 320
317 321 JNIEXPORT jlong JNICALL
318 322 Java_sun_management_VMManagementImpl_getClassVerificationTime
319 323 (JNIEnv *env, jobject dummy)
320 324 {
321 325 return jmm_interface->GetLongAttribute(env, NULL,
322 326 JMM_CLASS_VERIFY_TOTAL_TIME_MS);
323 327 }
|
↓ open down ↓ |
215 lines elided |
↑ open up ↑ |
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX