1 /*
2 * Copyright (c) 2001, 2005, 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 * 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 * ANDROID-CHANGED: This module is almost totally re-written
36 * for android. On android, we have a limited number of jweak
37 * references that can be around at any one time. In order to
38 * preserve this limited resource for user-code use we keep
39 * track of the status of classes using JVMTI tags.
40 *
41 * We keep a linked-list of the signatures of loaded classes
42 * associated with the tag we gave to that class. The tag is
43 * simply incremented every time we add a new class.
44 *
45 * We also request (on the separate tracking jvmtiEnv) an
46 * ObjectFree event be called for each of these classes. This
47 * allows us to keep a running list of all the classes known to
48 * have been collected since the last call to
49 * classTrack_processUnloads. On each call to processUnloads we
50 * iterate through this list and remove from the main list all
51 * the objects that have been collected. We then return a list of
52 * the class-signatures that have been collected.
53 *
54 * For efficiency and simplicity we don't bother retagging or
55 * re-using old tags, instead relying on the fact that no
56 * program will ever be able to exhaust the (2^64 - 1) possible
57 * tag values (which would require that many class-loads).
58 *
59 * This relies on the tagging and ObjectFree implementation being
60 * relatively efficient for performance. It has the advantage of
61 * not requiring any jweaks.
62 *
63 * All calls into any function of this module must be either
64 * done before the event-handler system is setup or done while
65 * holding the event handlerLock. The list of freed classes is
66 * protected by the classTagLock.
67 */
68
69 #include "util.h"
70 #include "bag.h"
71 #include "classTrack.h"
72
73 typedef struct KlassNode {
74 jlong klass_tag; /* Tag the klass has in the tracking-env */
75 char *signature; /* class signature */
76 struct KlassNode *next; /* next node in this slot */
77 } KlassNode;
78
79 /*
80 * pointer to first node of a linked list of prepared classes KlassNodes.
81 */
82 static KlassNode *list;
83
84 /*
85 * The JVMTI env we use to keep track of klass tags which allows us to detect class-unloads.
86 */
87 static jvmtiEnv *trackingEnv;
88
89 /*
90 * The current highest tag number in use by the trackingEnv.
91 *
92 * No need for synchronization since everything is done under the handlerLock.
93 */
94 static jlong currentKlassTag;
95
96 /*
97 * A lock to protect access to 'deletedTagBag'
98 */
99 static jrawMonitorID deletedTagLock;
100
101 /*
102 * A bag containing all the deleted klass_tags ids. This must be accessed under the
103 * deletedTagLock.
104 *
105 * It is cleared each time classTrack_processUnloads is called.
106 */
107 struct bag* deletedTagBag;
108
109 /*
110 * The callback for when classes are freed. Only classes are called because this is registered with
111 * the trackingEnv which only tags classes.
112 */
113 static void JNICALL
cbTrackingObjectFree(jvmtiEnv * jvmti_env,jlong tag)114 cbTrackingObjectFree(jvmtiEnv* jvmti_env, jlong tag)
115 {
116 debugMonitorEnterNoSuspend(deletedTagLock);
117 *(jlong*)bagAdd(deletedTagBag) = tag;
118 debugMonitorExit(deletedTagLock);
119 }
120
121 /*
122 * Returns true (thus continuing the iteration) if the item is not the searched for tag.
123 */
124 static jboolean
isNotTag(void * item,void * needle)125 isNotTag(void* item, void* needle)
126 {
127 return *(jlong*)item != *(jlong*)needle;
128 }
129
130 /*
131 * This requires that deletedTagLock and the handlerLock are both held.
132 */
133 static jboolean
isClassUnloaded(jlong tag)134 isClassUnloaded(jlong tag)
135 {
136 /* bagEnumerateOver returns true if 'func' returns true on all items and aborts early if not. */
137 return !bagEnumerateOver(deletedTagBag, isNotTag, &tag);
138 }
139
140 /*
141 * Called after class unloads have occurred. Creates a new hash table
142 * of currently loaded prepared classes.
143 * The signatures of classes which were unloaded (not present in the
144 * new table) are returned.
145 *
146 * NB This relies on addPreparedClass being called for every class loaded after the
147 * classTrack_initialize function is called. We will not request all loaded classes again after
148 * that. It also relies on not being called concurrently with any classTrack_addPreparedClass or
149 * other classTrack_processUnloads calls.
150 */
151 struct bag *
classTrack_processUnloads(JNIEnv * env)152 classTrack_processUnloads(JNIEnv *env)
153 {
154 /* We could optimize this somewhat by holding the deletedTagLock for a much shorter time,
155 * replacing it as soon as we enter and then destroying it once we are done with it. This will
156 * cause a lot of memory churn and this function is not expected to be called that often.
157 * Furthermore due to the check for an empty bag (which should be very common) normally this
158 * will finish very quickly. In cases where there is a concurrent GC occuring and a class is
159 * being collected the GC-ing threads could be blocked until we are done but this is expected to
160 * be very rare.
161 */
162 debugMonitorEnter(deletedTagLock);
163 /* Take and return the deletedTagBag */
164 struct bag* deleted = bagCreateBag(sizeof(char*), bagSize(deletedTagBag));
165 /* The deletedTagBag is going to be much shorter than the klassNode list so we should walk the
166 * KlassNode list once and scan the deletedTagBag each time. We only need to this in the rare
167 * case that there was anything deleted though.
168 */
169 if (bagSize(deletedTagBag) != 0) {
170 KlassNode* node = list;
171 KlassNode** previousNext = &list;
172
173 while (node != NULL) {
174 if (isClassUnloaded(node->klass_tag)) {
175 /* Update the previous node's next pointer to point after this node. Note that we
176 * update the value pointed to by previousNext but not the value of previousNext
177 * itself.
178 */
179 *previousNext = node->next;
180 /* Put this nodes signature into the deleted bag */
181 *(char**)bagAdd(deleted) = node->signature;
182 /* Deallocate the node */
183 jvmtiDeallocate(node);
184 } else {
185 /* This node will become the previous node so update the previousNext pointer to
186 * this nodes next pointer.
187 */
188 previousNext = &(node->next);
189 }
190 node = *previousNext;
191 }
192 bagDeleteAll(deletedTagBag);
193 }
194 debugMonitorExit(deletedTagLock);
195 return deleted;
196 }
197
198 /*
199 * Add a class to the prepared class list.
200 * Assumes no duplicates.
201 */
202 void
classTrack_addPreparedClass(JNIEnv * env,jclass klass)203 classTrack_addPreparedClass(JNIEnv *env, jclass klass)
204 {
205 KlassNode *node;
206 jvmtiError error;
207
208 if (gdata->assertOn) {
209 /* Check this is not a duplicate */
210 jlong tag;
211 error = JVMTI_FUNC_PTR(trackingEnv,GetTag)(trackingEnv, klass, &tag);
212 if (error != JVMTI_ERROR_NONE) {
213 EXIT_ERROR(error,"unable to get-tag with class trackingEnv!");
214 }
215 if (tag != 0l) {
216 JDI_ASSERT_FAILED("Attempting to insert duplicate class");
217 }
218 }
219
220 node = jvmtiAllocate(sizeof(KlassNode));
221 if (node == NULL) {
222 EXIT_ERROR(AGENT_ERROR_OUT_OF_MEMORY,"KlassNode");
223 }
224 error = classSignature(klass, &(node->signature), NULL);
225 if (error != JVMTI_ERROR_NONE) {
226 jvmtiDeallocate(node);
227 EXIT_ERROR(error,"signature");
228 }
229 node->klass_tag = ++currentKlassTag;
230 error = JVMTI_FUNC_PTR(trackingEnv,SetTag)(trackingEnv, klass, node->klass_tag);
231 if (error != JVMTI_ERROR_NONE) {
232 jvmtiDeallocate(node->signature);
233 jvmtiDeallocate(node);
234 EXIT_ERROR(error,"SetTag");
235 }
236
237 /* Insert the new node */
238 node->next = list;
239 list = node;
240 }
241
242 static jboolean
setupEvents()243 setupEvents()
244 {
245 jvmtiCapabilities caps;
246 memset(&caps, 0, sizeof(caps));
247 caps.can_generate_object_free_events = 1;
248 jvmtiError error = JVMTI_FUNC_PTR(trackingEnv,AddCapabilities)(trackingEnv, &caps);
249 if (error != JVMTI_ERROR_NONE) {
250 return JNI_FALSE;
251 }
252 jvmtiEventCallbacks cb;
253 memset(&cb, 0, sizeof(cb));
254 cb.ObjectFree = cbTrackingObjectFree;
255 error = JVMTI_FUNC_PTR(trackingEnv,SetEventCallbacks)(trackingEnv, &cb, sizeof(cb));
256 if (error != JVMTI_ERROR_NONE) {
257 return JNI_FALSE;
258 }
259 error = JVMTI_FUNC_PTR(trackingEnv,SetEventNotificationMode)
260 (trackingEnv, JVMTI_ENABLE, JVMTI_EVENT_OBJECT_FREE, NULL);
261 if (error != JVMTI_ERROR_NONE) {
262 return JNI_FALSE;
263 }
264 return JNI_TRUE;
265 }
266
267 /*
268 * Called once to build the initial prepared class hash table.
269 */
270 void
classTrack_initialize(JNIEnv * env)271 classTrack_initialize(JNIEnv *env)
272 {
273 /* ANDROID_CHANGED: Setup the tracking env and the currentKlassTag */
274 trackingEnv = getSpecialJvmti();
275 if ( trackingEnv == NULL ) {
276 EXIT_ERROR(AGENT_ERROR_INTERNAL,"Failed to allocate tag-tracking jvmtiEnv");
277 }
278 /* We want to create these before turning on the events or tagging anything. */
279 deletedTagLock = debugMonitorCreate("Deleted class tag lock");
280 deletedTagBag = bagCreateBag(sizeof(jlong), 10);
281 /* ANDROID-CHANGED: Setup the trackingEnv's ObjectFree event */
282 if (!setupEvents()) {
283 /* On android classes are usually not unloaded too often so this is not a huge loss. */
284 ERROR_MESSAGE(("Unable to setup class ObjectFree tracking! Class unloads will not "
285 "be reported!"));
286 }
287 currentKlassTag = 0l;
288 list = NULL;
289 WITH_LOCAL_REFS(env, 1) {
290
291 jint classCount;
292 jclass *classes;
293 jvmtiError error;
294 jint i;
295
296 error = allLoadedClasses(&classes, &classCount);
297 if ( error == JVMTI_ERROR_NONE ) {
298 for (i=0; i<classCount; i++) {
299 jclass klass = classes[i];
300 jint status;
301 jint wanted =
302 (JVMTI_CLASS_STATUS_PREPARED|JVMTI_CLASS_STATUS_ARRAY);
303
304 /* We only want prepared classes and arrays */
305 status = classStatus(klass);
306 if ( (status & wanted) != 0 ) {
307 classTrack_addPreparedClass(env, klass);
308 }
309 }
310 jvmtiDeallocate(classes);
311 } else {
312 EXIT_ERROR(error,"loaded classes array");
313 }
314
315 } END_WITH_LOCAL_REFS(env)
316
317 }
318
319 void
classTrack_reset(void)320 classTrack_reset(void)
321 {
322 }
323