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
51typedef 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 */
61static KlassNode **table;
62
63/*
64 * Return slot in hash table to use for this class.
65 */
66static jint
67hashKlass(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 */
77static void
78transferClass(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 */
117static struct bag *
118deleteTable(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 */
160struct bag *
161classTrack_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 */
210void
211classTrack_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 */
251void
252classTrack_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
291void
292classTrack_reset(void)
293{
294}
295