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 * This module tracks classes that have been prepared, so as to
27 * be able to compute which have been unloaded. On VM start-up
28 * all prepared classes are put in a table. As class prepare
29 * events come in they are added to the table. After an unload
30 * event or series of them, the VM can be asked for the list
31 * of classes; this list is compared against the table keep by
32 * this module, any classes no longer present are known to
33 * have been unloaded.
34 *
35 * For efficient access, classes are keep in a hash table.
36 * Each slot in the hash table has a linked list of KlassNode.
37 *
38 * Comparing current set of classes is compared with previous
39 * set by transferring all classes in the current set into
40 * a new table, any that remain in the old table have been
41 * unloaded.
42 */
43
44 #include "util.h"
45 #include "bag.h"
46 #include "classTrack.h"
47
48 /* ClassTrack hash table slot count */
49 #define CT_HASH_SLOT_COUNT 263 /* Prime which eauals 4k+3 for some k */
50
51 typedef struct KlassNode {
52 jclass klass; /* weak global reference */
53 char *signature; /* class signature */
54 struct KlassNode *next; /* next node in this slot */
55 } KlassNode;
56
57 /*
58 * Hash table of prepared classes. Each entry is a pointer
59 * to a linked list of KlassNode.
60 */
61 static KlassNode **table;
62
63 /*
64 * Return slot in hash table to use for this class.
65 */
66 static jint
67 hashKlass(jclass klass)
68 {
69 jint hashCode = objectHashCode(klass);
70 return abs(hashCode) % CT_HASH_SLOT_COUNT;
71 }
72
73 /*
74 * Transfer a node (which represents klass) from the current
75 * table to the new table.
76 */
77 static void
78 transferClass(JNIEnv *env, jclass klass, KlassNode **newTable) {
79 jint slot = hashKlass(klass);
80 KlassNode **head = &table[slot];
81 KlassNode **newHead = &newTable[slot];
82 KlassNode **nodePtr;
83 KlassNode *node;
84
85 /* Search the node list of the current table for klass */
86 for (nodePtr = head; node = *nodePtr, node != NULL; nodePtr = &(node->next)) {
87 if (isSameObject(env, klass, node->klass)) {
88 /* Match found transfer node */
89
90 /* unlink from old list */
91 *nodePtr = node->next;
92
93 /* insert in new list */
94 node->next = *newHead;
95 *newHead = node;
96
97 return;
98 }
99 }
100
101 /* we haven't found the class, only unloads should have happenned,
102 * so the only reason a class should not have been found is
103 * that it is not prepared yet, in which case we don't want it.
104 * Asset that the above is true.
105 */
106 /**** the HotSpot VM doesn't create prepare events for some internal classes ***
107 JDI_ASSERT_MSG((classStatus(klass) &
108 (JVMTI_CLASS_STATUS_PREPARED|JVMTI_CLASS_STATUS_ARRAY))==0,
109 classSignature(klass));
110 ***/
111 }
112
113 /*
114 * Delete a hash table of classes.
115 * The signatures of classes in the table are returned.
116 */
117 static struct bag *
118 deleteTable(JNIEnv *env, KlassNode *oldTable[])
119 {
120 struct bag *signatures = bagCreateBag(sizeof(char*), 10);
121 jint slot;
122
123 if (signatures == NULL) {
124 EXIT_ERROR(AGENT_ERROR_OUT_OF_MEMORY,"signatures");
125 }
126
127 for (slot = 0; slot < CT_HASH_SLOT_COUNT; slot++) {
128 KlassNode *node = oldTable[slot];
129
130 while (node != NULL) {
131 KlassNode *next;
132 char **sigSpot;
133
134 /* Add signature to the signature bag */
135 sigSpot = bagAdd(signatures);
136 if (sigSpot == NULL) {
137 EXIT_ERROR(AGENT_ERROR_OUT_OF_MEMORY,"signature bag");
138 }
139 *sigSpot = node->signature;
140
141 /* Free weak ref and the node itself */
142 JNI_FUNC_PTR(env,DeleteWeakGlobalRef)(env, node->klass);
143 next = node->next;
144 jvmtiDeallocate(node);
145
146 node = next;
147 }
148 }
149 jvmtiDeallocate(oldTable);
150
151 return signatures;
152 }
153
154 /*
155 * Called after class unloads have occurred. Creates a new hash table
156 * of currently loaded prepared classes.
157 * The signatures of classes which were unloaded (not present in the
158 * new table) are returned.
159 */
160 struct bag *
161 classTrack_processUnloads(JNIEnv *env)
162 {
163 KlassNode **newTable;
164 struct bag *unloadedSignatures;
165
166 unloadedSignatures = NULL;
167 newTable = jvmtiAllocate(CT_HASH_SLOT_COUNT * sizeof(KlassNode *));
168 if (newTable == NULL) {
169 EXIT_ERROR(AGENT_ERROR_OUT_OF_MEMORY, "classTrack table");
170 } else {
171
172 (void)memset(newTable, 0, CT_HASH_SLOT_COUNT * sizeof(KlassNode *));
173
174 WITH_LOCAL_REFS(env, 1) {
175
176 jint classCount;
177 jclass *classes;
178 jvmtiError error;
179 int i;
180
181 error = allLoadedClasses(&classes, &classCount);
182 if ( error != JVMTI_ERROR_NONE ) {
183 jvmtiDeallocate(newTable);
184 EXIT_ERROR(error,"loaded classes");
185 } else {
186
187 /* Transfer each current class into the new table */
188 for (i=0; i<classCount; i++) {
189 jclass klass = classes[i];
190 transferClass(env, klass, newTable);
191 }
192 jvmtiDeallocate(classes);
193
194 /* Delete old table, install new one */
195 unloadedSignatures = deleteTable(env, table);
196 table = newTable;
197 }
198
199 } END_WITH_LOCAL_REFS(env)
200
201 }
202
203 return unloadedSignatures;
204 }
205
206 /*
207 * Add a class to the prepared class hash table.
208 * Assumes no duplicates.
209 */
210 void
211 classTrack_addPreparedClass(JNIEnv *env, jclass klass)
212 {
213 jint slot = hashKlass(klass);
214 KlassNode **head = &table[slot];
215 KlassNode *node;
216 jvmtiError error;
217
218 if (gdata->assertOn) {
219 /* Check this is not a duplicate */
220 for (node = *head; node != NULL; node = node->next) {
221 if (isSameObject(env, klass, node->klass)) {
222 JDI_ASSERT_FAILED("Attempting to insert duplicate class");
223 break;
224 }
225 }
226 }
227
228 node = jvmtiAllocate(sizeof(KlassNode));
229 if (node == NULL) {
230 EXIT_ERROR(AGENT_ERROR_OUT_OF_MEMORY,"KlassNode");
231 }
232 error = classSignature(klass, &(node->signature), NULL);
233 if (error != JVMTI_ERROR_NONE) {
234 jvmtiDeallocate(node);
235 EXIT_ERROR(error,"signature");
236 }
237 if ((node->klass = JNI_FUNC_PTR(env,NewWeakGlobalRef)(env, klass)) == NULL) {
238 jvmtiDeallocate(node->signature);
239 jvmtiDeallocate(node);
240 EXIT_ERROR(AGENT_ERROR_NULL_POINTER,"NewWeakGlobalRef");
241 }
242
243 /* Insert the new node */
244 node->next = *head;
245 *head = node;
246 }
247
248 /*
249 * Called once to build the initial prepared class hash table.
250 */
251 void
252 classTrack_initialize(JNIEnv *env)
253 {
254 WITH_LOCAL_REFS(env, 1) {
255
256 jint classCount;
257 jclass *classes;
258 jvmtiError error;
259 jint i;
260
261 error = allLoadedClasses(&classes, &classCount);
262 if ( error == JVMTI_ERROR_NONE ) {
263 table = jvmtiAllocate(CT_HASH_SLOT_COUNT * sizeof(KlassNode *));
264 if (table != NULL) {
265 (void)memset(table, 0, CT_HASH_SLOT_COUNT * sizeof(KlassNode *));
266 for (i=0; i<classCount; i++) {
267 jclass klass = classes[i];
268 jint status;
269 jint wanted =
270 (JVMTI_CLASS_STATUS_PREPARED|JVMTI_CLASS_STATUS_ARRAY);
271
272 /* We only want prepared classes and arrays */
273 status = classStatus(klass);
274 if ( (status & wanted) != 0 ) {
275 classTrack_addPreparedClass(env, klass);
276 }
277 }
278 } else {
279 jvmtiDeallocate(classes);
280 EXIT_ERROR(AGENT_ERROR_OUT_OF_MEMORY,"KlassNode");
281 }
282 jvmtiDeallocate(classes);
283 } else {
284 EXIT_ERROR(error,"loaded classes array");
285 }
286
287 } END_WITH_LOCAL_REFS(env)
288
289 }
290
291 void
292 classTrack_reset(void)
293 {
294 }
|
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 /*
27 * This module tracks classes that have been prepared, so as to
28 * be able to report which have been unloaded. On VM start-up
29 * and whenever new classes are loaded, all prepared classes'
30 * signatures are attached as JVMTI tag to the class object.
31 * Class unloading is tracked by registering
32 * ObjectFree callback on class objects. When this happens, we find
33 * the signature of the unloaded class(es) and report them back
34 * to the event handler to synthesize class-unload-events.
35 */
36
37 #include "util.h"
38 #include "bag.h"
39 #include "classTrack.h"
40
41 /*
42 * The JVMTI tracking env to keep track of klass tags for class-unloads
43 */
44 static jvmtiEnv* trackingEnv;
45
46 /*
47 * A bag containing all the deleted classes' signatures. Must be accessed under
48 * classTrackLock.
49 */
50 struct bag* deletedSignatures;
51
52 /*
53 * Lock to keep integrity of deletedSignatures.
54 */
55 static jrawMonitorID classTrackLock;
56
57 /*
58 * Invoke the callback when classes are freed, find and record the signature
59 * in deletedSignatures. Those are only used in addPreparedClass() by the
60 * same thread.
61 */
62 static void JNICALL
63 cbTrackingObjectFree(jvmtiEnv* jvmti_env, jlong tag)
64 {
65 debugMonitorEnter(classTrackLock);
66 if (deletedSignatures == NULL) {
67 debugMonitorExit(classTrackLock);
68 return;
69 }
70 *(char**)bagAdd(deletedSignatures) = (char*)tag;
71
72 debugMonitorExit(classTrackLock);
73 }
74
75 /*
76 * Called after class unloads have occurred.
77 * The signatures of classes which were unloaded are returned.
78 */
79 struct bag *
80 classTrack_processUnloads(JNIEnv *env)
81 {
82 debugMonitorEnter(classTrackLock);
83 if (deletedSignatures == NULL) {
84 // Class tracking not initialized, nobody's interested.
85 debugMonitorExit(classTrackLock);
86 return NULL;
87 }
88 struct bag* deleted = deletedSignatures;
89 deletedSignatures = bagCreateBag(sizeof(char*), 10);
90 debugMonitorExit(classTrackLock);
91 return deleted;
92 }
93
94 /*
95 * Add a class to the prepared class table.
96 */
97 void
98 classTrack_addPreparedClass(JNIEnv *env_unused, jclass klass)
99 {
100 jvmtiError error;
101
102 jvmtiEnv* env = trackingEnv;
103
104 // Check this is not already tagged.
105 jlong tag;
106 error = JVMTI_FUNC_PTR(trackingEnv, GetTag)(env, klass, &tag);
107 if (error != JVMTI_ERROR_NONE) {
108 EXIT_ERROR(error, "Unable to GetTag with class trackingEnv");
109 }
110 if (tag != 0l) {
111 return; // Already added
112 }
113
114 char* signature;
115 error = classSignature(klass, &signature, NULL);
116 if (error != JVMTI_ERROR_NONE) {
117 EXIT_ERROR(error,"signature");
118 }
119 error = JVMTI_FUNC_PTR(trackingEnv, SetTag)(env, klass, (jlong)signature);
120 if (error != JVMTI_ERROR_NONE) {
121 jvmtiDeallocate(signature);
122 EXIT_ERROR(error,"SetTag");
123 }
124
125 }
126
127 static jboolean
128 setupEvents()
129 {
130 jvmtiCapabilities caps;
131 memset(&caps, 0, sizeof(caps));
132 caps.can_generate_object_free_events = 1;
133 jvmtiError error = JVMTI_FUNC_PTR(trackingEnv, AddCapabilities)(trackingEnv, &caps);
134 if (error != JVMTI_ERROR_NONE) {
135 return JNI_FALSE;
136 }
137 jvmtiEventCallbacks cb;
138 memset(&cb, 0, sizeof(cb));
139 cb.ObjectFree = cbTrackingObjectFree;
140 error = JVMTI_FUNC_PTR(trackingEnv, SetEventCallbacks)(trackingEnv, &cb, sizeof(cb));
141 if (error != JVMTI_ERROR_NONE) {
142 return JNI_FALSE;
143 }
144 error = JVMTI_FUNC_PTR(trackingEnv, SetEventNotificationMode)(trackingEnv, JVMTI_ENABLE, JVMTI_EVENT_OBJECT_FREE, NULL);
145 if (error != JVMTI_ERROR_NONE) {
146 return JNI_FALSE;
147 }
148 return JNI_TRUE;
149 }
150
151 /*
152 * Called once to initialize class-tracking.
153 */
154 void
155 classTrack_initialize(JNIEnv *env)
156 {
157 deletedSignatures = NULL;
158 classTrackLock = debugMonitorCreate("Deleted class tag lock");
159 trackingEnv = getSpecialJvmti();
160 if (trackingEnv == NULL) {
161 EXIT_ERROR(AGENT_ERROR_INTERNAL, "Failed to allocate tag-tracking jvmtiEnv");
162 }
163
164
165 if (!setupEvents()) {
166 EXIT_ERROR(AGENT_ERROR_INTERNAL, "Unable to setup ObjectFree tracking");
167 }
168
169 jint classCount;
170 jclass *classes;
171 jvmtiError error;
172 jint i;
173
174 error = allLoadedClasses(&classes, &classCount);
175 if ( error == JVMTI_ERROR_NONE ) {
176 for (i = 0; i < classCount; i++) {
177 jclass klass = classes[i];
178 jint status;
179 jint wanted = JVMTI_CLASS_STATUS_PREPARED | JVMTI_CLASS_STATUS_ARRAY;
180 status = classStatus(klass);
181 if ((status & wanted) != 0) {
182 classTrack_addPreparedClass(env, klass);
183 }
184 }
185 jvmtiDeallocate(classes);
186 } else {
187 EXIT_ERROR(error,"loaded classes array");
188 }
189 }
190
191 /*
192 * Called to activate class-tracking when a listener registers for EI_GC_FINISH.
193 */
194 void
195 classTrack_activate(JNIEnv *env)
196 {
197 debugMonitorEnter(classTrackLock);
198 deletedSignatures = bagCreateBag(sizeof(char*), 1000);
199 debugMonitorExit(classTrackLock);
200 }
201
202 static jboolean
203 cleanDeleted(void *signatureVoid, void *arg)
204 {
205 char* sig = *(char**)signatureVoid;
206 jvmtiDeallocate(sig);
207 return JNI_TRUE;
208 }
209
210 /*
211 * Called when agent detaches.
212 */
213 void
214 classTrack_reset(void)
215 {
216 debugMonitorEnter(classTrackLock);
217
218 bagEnumerateOver(deletedSignatures, cleanDeleted, NULL);
219 bagDestroyBag(deletedSignatures);
220 deletedSignatures = NULL;
221
222 debugMonitorExit(classTrackLock);
223 }
|