src/share/back/classTrack.c - platform/external/oj-libjdwp - Git at Google

 /*
  * Copyright (c) 2001, 2005, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License version 2 only, as
  * published by the Free Software Foundation.  Oracle designates this
  * particular file as subject to the "Classpath" exception as provided
  * by Oracle in the LICENSE file that accompanied this code.
  *
  * This code is distributed in the hope that it will be useful, but WITHOUT
  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  * version 2 for more details (a copy is included in the LICENSE file that
  * accompanied this code).
  *
  * You should have received a copy of the GNU General Public License version
  * 2 along with this work; if not, write to the Free Software Foundation,
  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  *
  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  * or visit www.oracle.com if you need additional information or have any
  * questions.
  */
 /*
  * This module tracks classes that have been prepared, so as to
  * be able to compute which have been unloaded.  On VM start-up
  * all prepared classes are put in a table.  As class prepare
  * events come in they are added to the table.  After an unload
  * event or series of them, the VM can be asked for the list
  * of classes; this list is compared against the table keep by
  * this module, any classes no longer present are known to
  * have been unloaded.
  *
  * ANDROID-CHANGED: This module is almost totally re-written
  * for android. On android, we have a limited number of jweak
  * references that can be around at any one time. In order to
  * preserve this limited resource for user-code use we keep
  * track of the status of classes using JVMTI tags.
  *
  * We keep a linked-list of the signatures of loaded classes
  * associated with the tag we gave to that class. The tag is
  * simply incremented every time we add a new class.
  *
  * We also request (on the separate tracking jvmtiEnv) an
  * ObjectFree event be called for each of these classes. This
  * allows us to keep a running list of all the classes known to
  * have been collected since the last call to
  * classTrack_processUnloads. On each call to processUnloads we
  * iterate through this list and remove from the main list all
  * the objects that have been collected. We then return a list of
  * the class-signatures that have been collected.
  *
  * For efficiency and simplicity we don't bother retagging or
  * re-using old tags, instead relying on the fact that no
  * program will ever be able to exhaust the (2^64 - 1) possible
  * tag values (which would require that many class-loads).
  *
  * This relies on the tagging and ObjectFree implementation being
  * relatively efficient for performance. It has the advantage of
  * not requiring any jweaks.
  *
  * All calls into any function of this module must be either
  * done before the event-handler system is setup or done while
  * holding the event handlerLock. The list of freed classes is
  * protected by the classTagLock.
  */

 #include "util.h"
 #include "bag.h"
 #include "classTrack.h"

 typedef struct KlassNode {
     jlong klass_tag;         /* Tag the klass has in the tracking-env */
     char *signature;         /* class signature */
     struct KlassNode *next;  /* next node in this slot */
 } KlassNode;

 /*
  * pointer to first node of a linked list of prepared classes KlassNodes.
  */
 static KlassNode *list;

 /*
  * The JVMTI env we use to keep track of klass tags which allows us to detect class-unloads.
  */
 static jvmtiEnv *trackingEnv;

 /*
  * The current highest tag number in use by the trackingEnv.
  *
  * No need for synchronization since everything is done under the handlerLock.
  */
 static jlong currentKlassTag;

 /*
  * A lock to protect access to 'deletedTagBag'
  */
 static jrawMonitorID deletedTagLock;

 /*
  * A bag containing all the deleted klass_tags ids. This must be accessed under the
  * deletedTagLock.
  *
  * It is cleared each time classTrack_processUnloads is called.
  */
 struct bag* deletedTagBag;

 /*
  * The callback for when classes are freed. Only classes are called because this is registered with
  * the trackingEnv which only tags classes.
  */
 static void JNICALL
 cbTrackingObjectFree(jvmtiEnv* jvmti_env, jlong tag)
 {
     debugMonitorEnter(deletedTagLock);
     *(jlong*)bagAdd(deletedTagBag) = tag;
     debugMonitorExit(deletedTagLock);
 }

 /*
  * Returns true (thus continuing the iteration) if the item is not the searched for tag.
  */
 static jboolean
 isNotTag(void* item, void* needle)
 {
     return *(jlong*)item != *(jlong*)needle;
 }

 /*
  * This requires that deletedTagLock and the handlerLock are both held.
  */
 static jboolean
 isClassUnloaded(jlong tag)
 {
     /* bagEnumerateOver returns true if 'func' returns true on all items and aborts early if not. */
     return !bagEnumerateOver(deletedTagBag, isNotTag, &tag);
 }

 /*
  * Called after class unloads have occurred.  Creates a new hash table
  * of currently loaded prepared classes.
  * The signatures of classes which were unloaded (not present in the
  * new table) are returned.
  *
  * NB This relies on addPreparedClass being called for every class loaded after the
  * classTrack_initialize function is called. We will not request all loaded classes again after
  * that. It also relies on not being called concurrently with any classTrack_addPreparedClass or
  * other classTrack_processUnloads calls.
  */
 struct bag *
 classTrack_processUnloads(JNIEnv *env)
 {
     /* We could optimize this somewhat by holding the deletedTagLock for a much shorter time,
      * replacing it as soon as we enter and then destroying it once we are done with it. This will
      * cause a lot of memory churn and this function is not expected to be called that often.
      * Furthermore due to the check for an empty bag (which should be very common) normally this
      * will finish very quickly. In cases where there is a concurrent GC occuring and a class is
      * being collected the GC-ing threads could be blocked until we are done but this is expected to
      * be very rare.
      */
     debugMonitorEnter(deletedTagLock);
     /* Take and return the deletedTagBag */
     struct bag* deleted = bagCreateBag(sizeof(char*), bagSize(deletedTagBag));
     /* The deletedTagBag is going to be much shorter than the klassNode list so we should walk the
      * KlassNode list once and scan the deletedTagBag each time. We only need to this in the rare
      * case that there was anything deleted though.
      */
     if (bagSize(deletedTagBag) != 0) {
         KlassNode* node = list;
         KlassNode** previousNext = &list;

         while (node != NULL) {
             if (isClassUnloaded(node->klass_tag)) {
                 /* Update the previous node's next pointer to point after this node. Note that we
                  * update the value pointed to by previousNext but not the value of previousNext
                  * itself.
                  */
                 *previousNext = node->next;
                 /* Put this nodes signature into the deleted bag */
                 *(char**)bagAdd(deleted) = node->signature;
                 /* Deallocate the node */
                 jvmtiDeallocate(node);
             } else {
                 /* This node will become the previous node so update the previousNext pointer to
                  * this nodes next pointer.
                  */
                 previousNext = &(node->next);
             }
             node = *previousNext;
         }
         bagDeleteAll(deletedTagBag);
     }
     debugMonitorExit(deletedTagLock);
     return deleted;
 }

 /*
  * Add a class to the prepared class list.
  * Assumes no duplicates.
  */
 void
 classTrack_addPreparedClass(JNIEnv *env, jclass klass)
 {
     KlassNode *node;
     jvmtiError error;

     if (gdata->assertOn) {
         /* Check this is not a duplicate */
         jlong tag;
         error = JVMTI_FUNC_PTR(trackingEnv,GetTag)(trackingEnv, klass, &tag);
         if (error != JVMTI_ERROR_NONE) {
             EXIT_ERROR(error,"unable to get-tag with class trackingEnv!");
         }
         if (tag != 0l) {
             JDI_ASSERT_FAILED("Attempting to insert duplicate class");
         }
     }

     node = jvmtiAllocate(sizeof(KlassNode));
     if (node == NULL) {
         EXIT_ERROR(AGENT_ERROR_OUT_OF_MEMORY,"KlassNode");
     }
     error = classSignature(klass, &(node->signature), NULL);
     if (error != JVMTI_ERROR_NONE) {
         jvmtiDeallocate(node);
         EXIT_ERROR(error,"signature");
     }
     node->klass_tag = ++currentKlassTag;
     error = JVMTI_FUNC_PTR(trackingEnv,SetTag)(trackingEnv, klass, node->klass_tag);
     if (error != JVMTI_ERROR_NONE) {
         jvmtiDeallocate(node->signature);
         jvmtiDeallocate(node);
         EXIT_ERROR(error,"SetTag");
     }

     /* Insert the new node */
     node->next = list;
     list = node;
 }

 static jboolean
 setupEvents()
 {
     jvmtiCapabilities caps;
     memset(&caps, 0, sizeof(caps));
     caps.can_generate_object_free_events = 1;
     jvmtiError error = JVMTI_FUNC_PTR(trackingEnv,AddCapabilities)(trackingEnv, &caps);
     if (error != JVMTI_ERROR_NONE) {
         return JNI_FALSE;
     }
     jvmtiEventCallbacks cb;
     memset(&cb, 0, sizeof(cb));
     cb.ObjectFree = cbTrackingObjectFree;
     error = JVMTI_FUNC_PTR(trackingEnv,SetEventCallbacks)(trackingEnv, &cb, sizeof(cb));
     if (error != JVMTI_ERROR_NONE) {
         return JNI_FALSE;
     }
     error = JVMTI_FUNC_PTR(trackingEnv,SetEventNotificationMode)
             (trackingEnv, JVMTI_ENABLE, JVMTI_EVENT_OBJECT_FREE, NULL);
     if (error != JVMTI_ERROR_NONE) {
         return JNI_FALSE;
     }
     return JNI_TRUE;
 }

 /*
  * Called once to build the initial prepared class hash table.
  */
 void
 classTrack_initialize(JNIEnv *env)
 {
     /* ANDROID_CHANGED: Setup the tracking env and the currentKlassTag */
     trackingEnv = getSpecialJvmti();
     if ( trackingEnv == NULL ) {
         EXIT_ERROR(AGENT_ERROR_INTERNAL,"Failed to allocate tag-tracking jvmtiEnv");
     }
     /* We want to create these before turning on the events or tagging anything. */
     deletedTagLock = debugMonitorCreate("Deleted class tag lock");
     deletedTagBag = bagCreateBag(sizeof(jlong), 10);
     /* ANDROID-CHANGED: Setup the trackingEnv's ObjectFree event */
     if (!setupEvents()) {
         /* On android classes are usually not unloaded too often so this is not a huge loss. */
         ERROR_MESSAGE(("Unable to setup class ObjectFree tracking! Class unloads will not "
                        "be reported!"));
     }
     currentKlassTag = 0l;
     list = NULL;
     WITH_LOCAL_REFS(env, 1) {

         jint classCount;
         jclass *classes;
         jvmtiError error;
         jint i;

         error = allLoadedClasses(&classes, &classCount);
         if ( error == JVMTI_ERROR_NONE ) {
             for (i=0; i<classCount; i++) {
                 jclass klass = classes[i];
                 jint status;
                 jint wanted =
                     (JVMTI_CLASS_STATUS_PREPARED|JVMTI_CLASS_STATUS_ARRAY);

                 /* We only want prepared classes and arrays */
                 status = classStatus(klass);
                 if ( (status & wanted) != 0 ) {
                     classTrack_addPreparedClass(env, klass);
                 }
             }
             jvmtiDeallocate(classes);
         } else {
             EXIT_ERROR(error,"loaded classes array");
         }

     } END_WITH_LOCAL_REFS(env)

 }

 void
 classTrack_reset(void)
 {
 }
	/*
	* Copyright (c) 2001, 2005, Oracle and/or its affiliates. All rights reserved.
	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	*
	* This code is free software; you can redistribute it and/or modify it
	* under the terms of the GNU General Public License version 2 only, as
	* published by the Free Software Foundation. Oracle designates this
	* particular file as subject to the "Classpath" exception as provided
	* by Oracle in the LICENSE file that accompanied this code.
	*
	* This code is distributed in the hope that it will be useful, but WITHOUT
	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	* version 2 for more details (a copy is included in the LICENSE file that
	* accompanied this code).
	*
	* You should have received a copy of the GNU General Public License version
	* 2 along with this work; if not, write to the Free Software Foundation,
	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	*
	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	* or visit www.oracle.com if you need additional information or have any
	* questions.
	*/
	/*
	* This module tracks classes that have been prepared, so as to
	* be able to compute which have been unloaded. On VM start-up
	* all prepared classes are put in a table. As class prepare
	* events come in they are added to the table. After an unload
	* event or series of them, the VM can be asked for the list
	* of classes; this list is compared against the table keep by
	* this module, any classes no longer present are known to
	* have been unloaded.
	*
	* ANDROID-CHANGED: This module is almost totally re-written
	* for android. On android, we have a limited number of jweak
	* references that can be around at any one time. In order to
	* preserve this limited resource for user-code use we keep
	* track of the status of classes using JVMTI tags.
	*
	* We keep a linked-list of the signatures of loaded classes
	* associated with the tag we gave to that class. The tag is
	* simply incremented every time we add a new class.
	*
	* We also request (on the separate tracking jvmtiEnv) an
	* ObjectFree event be called for each of these classes. This
	* allows us to keep a running list of all the classes known to
	* have been collected since the last call to
	* classTrack_processUnloads. On each call to processUnloads we
	* iterate through this list and remove from the main list all
	* the objects that have been collected. We then return a list of
	* the class-signatures that have been collected.
	*
	* For efficiency and simplicity we don't bother retagging or
	* re-using old tags, instead relying on the fact that no
	* program will ever be able to exhaust the (2^64 - 1) possible
	* tag values (which would require that many class-loads).
	*
	* This relies on the tagging and ObjectFree implementation being
	* relatively efficient for performance. It has the advantage of
	* not requiring any jweaks.
	*
	* All calls into any function of this module must be either
	* done before the event-handler system is setup or done while
	* holding the event handlerLock. The list of freed classes is
	* protected by the classTagLock.
	*/

	#include "util.h"
	#include "bag.h"
	#include "classTrack.h"

	typedef struct KlassNode {
	jlong klass_tag; /* Tag the klass has in the tracking-env */
	char signature; / class signature */
	struct KlassNode next; / next node in this slot */
	} KlassNode;

	/*
	* pointer to first node of a linked list of prepared classes KlassNodes.
	*/
	static KlassNode *list;

	/*
	* The JVMTI env we use to keep track of klass tags which allows us to detect class-unloads.
	*/
	static jvmtiEnv *trackingEnv;

	/*
	* The current highest tag number in use by the trackingEnv.
	*
	* No need for synchronization since everything is done under the handlerLock.
	*/
	static jlong currentKlassTag;

	/*
	* A lock to protect access to 'deletedTagBag'
	*/
	static jrawMonitorID deletedTagLock;

	/*
	* A bag containing all the deleted klass_tags ids. This must be accessed under the
	* deletedTagLock.
	*
	* It is cleared each time classTrack_processUnloads is called.
	*/
	struct bag* deletedTagBag;

	/*
	* The callback for when classes are freed. Only classes are called because this is registered with
	* the trackingEnv which only tags classes.
	*/
	static void JNICALL
	cbTrackingObjectFree(jvmtiEnv* jvmti_env, jlong tag)
	{
	debugMonitorEnter(deletedTagLock);
	(jlong)bagAdd(deletedTagBag) = tag;
	debugMonitorExit(deletedTagLock);
	}

	/*
	* Returns true (thus continuing the iteration) if the item is not the searched for tag.
	*/
	static jboolean
	isNotTag(void* item, void* needle)
	{
	return (jlong)item != (jlong)needle;
	}

	/*
	* This requires that deletedTagLock and the handlerLock are both held.
	*/
	static jboolean
	isClassUnloaded(jlong tag)
	{
	/* bagEnumerateOver returns true if 'func' returns true on all items and aborts early if not. */
	return !bagEnumerateOver(deletedTagBag, isNotTag, &tag);
	}

	/*
	* Called after class unloads have occurred. Creates a new hash table
	* of currently loaded prepared classes.
	* The signatures of classes which were unloaded (not present in the
	* new table) are returned.
	*
	* NB This relies on addPreparedClass being called for every class loaded after the
	* classTrack_initialize function is called. We will not request all loaded classes again after
	* that. It also relies on not being called concurrently with any classTrack_addPreparedClass or
	* other classTrack_processUnloads calls.
	*/
	struct bag *
	classTrack_processUnloads(JNIEnv *env)
	{
	/* We could optimize this somewhat by holding the deletedTagLock for a much shorter time,
	* replacing it as soon as we enter and then destroying it once we are done with it. This will
	* cause a lot of memory churn and this function is not expected to be called that often.
	* Furthermore due to the check for an empty bag (which should be very common) normally this
	* will finish very quickly. In cases where there is a concurrent GC occuring and a class is
	* being collected the GC-ing threads could be blocked until we are done but this is expected to
	* be very rare.
	*/
	debugMonitorEnter(deletedTagLock);
	/* Take and return the deletedTagBag */
	struct bag* deleted = bagCreateBag(sizeof(char*), bagSize(deletedTagBag));
	/* The deletedTagBag is going to be much shorter than the klassNode list so we should walk the
	* KlassNode list once and scan the deletedTagBag each time. We only need to this in the rare
	* case that there was anything deleted though.
	*/
	if (bagSize(deletedTagBag) != 0) {
	KlassNode* node = list;
	KlassNode** previousNext = &list;

	while (node != NULL) {
	if (isClassUnloaded(node->klass_tag)) {
	/* Update the previous node's next pointer to point after this node. Note that we
	* update the value pointed to by previousNext but not the value of previousNext
	* itself.
	*/
	*previousNext = node->next;
	/* Put this nodes signature into the deleted bag */
	(char*)bagAdd(deleted) = node->signature;
	/* Deallocate the node */
	jvmtiDeallocate(node);
	} else {
	/* This node will become the previous node so update the previousNext pointer to
	* this nodes next pointer.
	*/
	previousNext = &(node->next);
	}
	node = *previousNext;
	}
	bagDeleteAll(deletedTagBag);
	}
	debugMonitorExit(deletedTagLock);
	return deleted;
	}

	/*
	* Add a class to the prepared class list.
	* Assumes no duplicates.
	*/
	void
	classTrack_addPreparedClass(JNIEnv *env, jclass klass)
	{
	KlassNode *node;
	jvmtiError error;

	if (gdata->assertOn) {
	/* Check this is not a duplicate */
	jlong tag;
	error = JVMTI_FUNC_PTR(trackingEnv,GetTag)(trackingEnv, klass, &tag);
	if (error != JVMTI_ERROR_NONE) {
	EXIT_ERROR(error,"unable to get-tag with class trackingEnv!");
	}
	if (tag != 0l) {
	JDI_ASSERT_FAILED("Attempting to insert duplicate class");
	}
	}

	node = jvmtiAllocate(sizeof(KlassNode));
	if (node == NULL) {
	EXIT_ERROR(AGENT_ERROR_OUT_OF_MEMORY,"KlassNode");
	}
	error = classSignature(klass, &(node->signature), NULL);
	if (error != JVMTI_ERROR_NONE) {
	jvmtiDeallocate(node);
	EXIT_ERROR(error,"signature");
	}
	node->klass_tag = ++currentKlassTag;
	error = JVMTI_FUNC_PTR(trackingEnv,SetTag)(trackingEnv, klass, node->klass_tag);
	if (error != JVMTI_ERROR_NONE) {
	jvmtiDeallocate(node->signature);
	jvmtiDeallocate(node);
	EXIT_ERROR(error,"SetTag");
	}

	/* Insert the new node */
	node->next = list;
	list = node;
	}

	static jboolean
	setupEvents()
	{
	jvmtiCapabilities caps;
	memset(&caps, 0, sizeof(caps));
	caps.can_generate_object_free_events = 1;
	jvmtiError error = JVMTI_FUNC_PTR(trackingEnv,AddCapabilities)(trackingEnv, &caps);
	if (error != JVMTI_ERROR_NONE) {
	return JNI_FALSE;
	}
	jvmtiEventCallbacks cb;
	memset(&cb, 0, sizeof(cb));
	cb.ObjectFree = cbTrackingObjectFree;
	error = JVMTI_FUNC_PTR(trackingEnv,SetEventCallbacks)(trackingEnv, &cb, sizeof(cb));
	if (error != JVMTI_ERROR_NONE) {
	return JNI_FALSE;
	}
	error = JVMTI_FUNC_PTR(trackingEnv,SetEventNotificationMode)
	(trackingEnv, JVMTI_ENABLE, JVMTI_EVENT_OBJECT_FREE, NULL);
	if (error != JVMTI_ERROR_NONE) {
	return JNI_FALSE;
	}
	return JNI_TRUE;
	}

	/*
	* Called once to build the initial prepared class hash table.
	*/
	void
	classTrack_initialize(JNIEnv *env)
	{
	/* ANDROID_CHANGED: Setup the tracking env and the currentKlassTag */
	trackingEnv = getSpecialJvmti();
	if ( trackingEnv == NULL ) {
	EXIT_ERROR(AGENT_ERROR_INTERNAL,"Failed to allocate tag-tracking jvmtiEnv");
	}
	/* We want to create these before turning on the events or tagging anything. */
	deletedTagLock = debugMonitorCreate("Deleted class tag lock");
	deletedTagBag = bagCreateBag(sizeof(jlong), 10);
	/* ANDROID-CHANGED: Setup the trackingEnv's ObjectFree event */
	if (!setupEvents()) {
	/* On android classes are usually not unloaded too often so this is not a huge loss. */
	ERROR_MESSAGE(("Unable to setup class ObjectFree tracking! Class unloads will not "
	"be reported!"));
	}
	currentKlassTag = 0l;
	list = NULL;
	WITH_LOCAL_REFS(env, 1) {

	jint classCount;
	jclass *classes;
	jvmtiError error;
	jint i;

	error = allLoadedClasses(&classes, &classCount);
	if ( error == JVMTI_ERROR_NONE ) {
	for (i=0; i<classCount; i++) {
	jclass klass = classes[i];
	jint status;
	jint wanted =
	(JVMTI_CLASS_STATUS_PREPARED\|JVMTI_CLASS_STATUS_ARRAY);

	/* We only want prepared classes and arrays */
	status = classStatus(klass);
	if ( (status & wanted) != 0 ) {
	classTrack_addPreparedClass(env, klass);
	}
	}
	jvmtiDeallocate(classes);
	} else {
	EXIT_ERROR(error,"loaded classes array");
	}

	} END_WITH_LOCAL_REFS(env)

	}

	void
	classTrack_reset(void)
	{
	}