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 * 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 }