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 }