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 }
|
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 table slot count */
49 #define CT_SLOT_COUNT 263 /* Prime which eauals 4k+3 for some k */
50
51 typedef struct KlassNode {
52 jlong klass_tag; /* Klass's tag in tracking env */
53 char *signature; /* class signature */
54 struct KlassNode *next; /* next node in this slot */
55 } KlassNode;
56
57 /*
58 * Table mapping tag % CT_SLOT_COUNT to linked-list of KlassNode*.
59 */
60 static KlassNode** table;
61
62 /*
63 * The JVMTI tracking env to keep track of klass tags, for class-unloads
64 */
65 static jvmtiEnv* trackingEnv;
66
67 /*
68 * The current highest tag number
69 */
70 static jlong currentClassTag;
71
72 /*
73 * Lock to protect deletedSignatureBag
74 */
75 static jrawMonitorID deletedSignatureLock;
76
77 /*
78 * A bag containing all the deleted classes' signatures. Must be accessed under
79 * deletedTagLock,
80 */
81 struct bag* deletedSignatureBag;
82
83 /*
84 * Callback when classes are freed, Finds the signature and remembers it in deletedSignatureBag.
85 */
86 static void JNICALL
87 cbTrackingObjectFree(jvmtiEnv* jvmti_env, jlong tag)
88 {
89 debugMonitorEnter(deletedSignatureLock);
90 if (currentClassTag == -1) {
91 // Class tracking not initialized, nobody's interested
92 debugMonitorExit(deletedSignatureLock);
93 return;
94 }
95
96 // Find deleted KlassNode
97 size_t idx = tag % CT_SLOT_COUNT;
98 KlassNode** klass_ptr = &table[idx];
99 KlassNode* klass = *klass_ptr;
100
101 // Tag not found? Ignore.
102 if (klass == NULL) {
103 debugMonitorExit(deletedSignatureLock);
104 return;
105 }
106
107 // Scan linked-list.
108 jlong found_tag = klass->klass_tag;
109 while (klass != NULL && found_tag != tag) {
110 klass_ptr = &klass->next;
111 klass = *klass_ptr;
112 found_tag = klass->klass_tag;
113 }
114
115 // Tag not found? Ignore.
116 if (found_tag != tag) {
117 debugMonitorExit(deletedSignatureLock);
118 return;
119 }
120
121 // At this point we have the KlassNode corresponding to the tag
122 // in klass, and the pointer to it in klass_node.
123 // Remember the unloaded signature.
124 *(char**)bagAdd(deletedSignatureBag) = klass->signature;
125
126 // Unlink the KlassNode.
127 *klass_ptr = klass->next;
128 jvmtiDeallocate(klass);
129
130 // Done.
131 debugMonitorExit(deletedSignatureLock);
132 }
133
134 /*
135 * Called after class unloads have occurred.
136 * The signatures of classes which were unloaded are returned.
137 */
138 struct bag *
139 classTrack_processUnloads(JNIEnv *env)
140 {
141 debugMonitorEnter(deletedSignatureLock);
142 if (currentClassTag == -1) {
143 // Class tracking not initialized, nobody's interested
144 debugMonitorExit(deletedSignatureLock);
145 return bagCreateBag(sizeof(char*), 0);
146 }
147 struct bag* deleted = deletedSignatureBag;
148 deletedSignatureBag = bagCreateBag(sizeof(char*), 10);
149 debugMonitorExit(deletedSignatureLock);
150 return deleted;
151 }
152
153 /*
154 * Add a class to the prepared class table.
155 */
156 void
157 classTrack_addPreparedClass(JNIEnv *env, jclass klass)
158 {
159 jvmtiError error;
160
161 debugMonitorEnter(deletedSignatureLock);
162 if (currentClassTag == -1) {
163 // Class tracking not initialized yet, nobody's interested
164 debugMonitorExit(deletedSignatureLock);
165 return;
166 }
167
168 /* Check this is not a duplicate */
169 jlong tag;
170 error = JVMTI_FUNC_PTR(trackingEnv, GetTag)(trackingEnv, klass, &tag);
171 if (error != JVMTI_ERROR_NONE) {
172 EXIT_ERROR(error, "Unable to GetTag with class trackingEnv");
173 }
174 if (tag != 0l) {
175 debugMonitorExit(deletedSignatureLock);
176 return; // Already added
177 }
178
179 KlassNode* node = jvmtiAllocate(sizeof(KlassNode));
180 if (node == NULL) {
181 EXIT_ERROR(AGENT_ERROR_OUT_OF_MEMORY,"KlassNode");
182 }
183 error = classSignature(klass, &(node->signature), NULL);
184 if (error != JVMTI_ERROR_NONE) {
185 jvmtiDeallocate(node);
186 EXIT_ERROR(error,"signature");
187 }
188 node->klass_tag = ++currentClassTag;
189 error = JVMTI_FUNC_PTR(trackingEnv, SetTag)(trackingEnv, klass, node->klass_tag);
190 if (error != JVMTI_ERROR_NONE) {
191 jvmtiDeallocate(node->signature);
192 jvmtiDeallocate(node);
193 EXIT_ERROR(error,"SetTag");
194 }
195
196 /* Insert the new node */
197 size_t idx = node->klass_tag % CT_SLOT_COUNT;
198 node->next = table[idx];
199 table[idx] = node;
200 debugMonitorExit(deletedSignatureLock);
201 }
202
203 static jboolean
204 setupEvents()
205 {
206 jvmtiCapabilities caps;
207 memset(&caps, 0, sizeof(caps));
208 caps.can_generate_object_free_events = 1;
209 jvmtiError error = JVMTI_FUNC_PTR(trackingEnv, AddCapabilities)(trackingEnv, &caps);
210 if (error != JVMTI_ERROR_NONE) {
211 return JNI_FALSE;
212 }
213 jvmtiEventCallbacks cb;
214 memset(&cb, 0, sizeof(cb));
215 cb.ObjectFree = cbTrackingObjectFree;
216 error = JVMTI_FUNC_PTR(trackingEnv, SetEventCallbacks)(trackingEnv, &cb, sizeof(cb));
217 if (error != JVMTI_ERROR_NONE) {
218 return JNI_FALSE;
219 }
220 error = JVMTI_FUNC_PTR(trackingEnv, SetEventNotificationMode)(trackingEnv, JVMTI_ENABLE, JVMTI_EVENT_OBJECT_FREE, NULL);
221 if (error != JVMTI_ERROR_NONE) {
222 return JNI_FALSE;
223 }
224 return JNI_TRUE;
225 }
226
227 /*
228 * Called once to initialize class-tracking.
229 */
230 void
231 classTrack_initialize(JNIEnv *env)
232 {
233 trackingEnv = getSpecialJvmti();
234 if (trackingEnv == NULL) {
235 EXIT_ERROR(AGENT_ERROR_INTERNAL, "Failed to allocate tag-tracking jvmtiEnv");
236 }
237 deletedSignatureLock = debugMonitorCreate("Deleted class tag lock");
238 deletedSignatureBag = bagCreateBag(sizeof(char*), 10);
239 currentClassTag = -1l;
240 table = NULL;
241 }
242
243 /*
244 * Called to activate class-tracking when a listener registers for EI_GC_FINISH.
245 */
246 void
247 classTrack_activate(JNIEnv *env)
248 {
249 if (!setupEvents()) {
250 EXIT_ERROR(AGENT_ERROR_INTERNAL, "Unable to setup ObjectFree tracking");
251 }
252 currentClassTag = 0l;
253 table = jvmtiAllocate(CT_SLOT_COUNT * sizeof(KlassNode*));
254 if (table != NULL) {
255 (void)memset(table, 0, CT_SLOT_COUNT * sizeof(KlassNode*));
256 } else {
257 EXIT_ERROR(AGENT_ERROR_OUT_OF_MEMORY, "failed allocating class-track table");
258 }
259
260 WITH_LOCAL_REFS(env, 1) {
261
262 jint classCount;
263 jclass *classes;
264 jvmtiError error;
265 jint i;
266
267 error = allLoadedClasses(&classes, &classCount);
268 if ( error == JVMTI_ERROR_NONE ) {
269 for (i = 0; i < classCount; i++) {
270 jclass klass = classes[i];
271 jint status;
272 jint wanted = JVMTI_CLASS_STATUS_PREPARED | JVMTI_CLASS_STATUS_ARRAY;
273 status = classStatus(klass);
274 if ((status & wanted) != 0) {
275 classTrack_addPreparedClass(env, klass);
276 }
277 }
278 jvmtiDeallocate(classes);
279 } else {
280 EXIT_ERROR(error,"loaded classes array");
281 }
282
283 } END_WITH_LOCAL_REFS(env)
284 }
285
286 static jboolean
287 cleanDeleted(void *signatureVoid, void *arg)
288 {
289 char* sig = (char*)signatureVoid;
290 jvmtiDeallocate(sig);
291 return JNI_TRUE;
292 }
293
294 /*
295 * Called when agent detaches.
296 */
297 void
298 classTrack_reset(void)
299 {
300 int idx;
301 debugMonitorEnter(deletedSignatureLock);
302
303 for (idx = 0; idx < CT_SLOT_COUNT; ++idx) {
304 KlassNode* node = table[idx];
305 while (node != NULL) {
306 KlassNode* next = node->next;
307 jvmtiDeallocate(node->signature);
308 jvmtiDeallocate(node);
309 node = next;
310 }
311 }
312 jvmtiDeallocate(table);
313
314 bagEnumerateOver(deletedSignatureBag, cleanDeleted, NULL);
315 bagDestroyBag(deletedSignatureBag);
316
317 currentClassTag = -1;
318
319 (void)JVMTI_FUNC_PTR(trackingEnv,DisposeEnvironment)(trackingEnv);
320 trackingEnv = NULL;
321
322 debugMonitorExit(deletedSignatureLock);
323 }
|