From 47461c8bd7427432bc0afe848db001e05f8d01a3 Mon Sep 17 00:00:00 2001

From: Jakub Filak <jfilak@redhat.com>

Date: Wed, 15 Jan 2014 11:49:36 +0100

Subject: [PATCH 24/39] Do not report exceptions caught by native methods

Related to rhbz#1051198

---

 src/abrt-checker.c | 247 ++++++++++++++++++++++++++++++++++++++++-------------

 src/jthread_map.c  |  26 +++---

 src/jthread_map.h  |  18 ++--

 3 files changed, 212 insertions(+), 79 deletions(-)

diff --git a/src/abrt-checker.c b/src/abrt-checker.c

index d5160cb..fb0c0eb 100644

--- a/src/abrt-checker.c

+++ b/src/abrt-checker.c

@@ -63,9 +63,6 @@

 /* Enables checks based on JVMTI_EVENT_VM_DEATH */

 /* #define ABRT_VM_DEATH_CHECK */

-/* Enables checks based on JVMTI_EVENT_EXCEPTION_CATCH  */

-/* #define ABRT_EXCEPTION_CATCH_CHECK */

-

 /* Enables checks based on JVMTI_EVENT_VM_OBJECT_ALLOC */

 /* #define ABRT_OBJECT_ALLOCATION_SIZE_CHECK */

@@ -165,6 +162,19 @@ typedef struct {

 /*

+ * This structure is representation of a single report of an exception.

+ */

+typedef struct {

+    char *message;

+    char *stacktrace;

+    char *executable;

+    char *exception_type_name;

+    jobject exception_object;

+} T_exceptionReport;

+

+

+

+/*

  * Flags for specification of destination for error reports

  */

 typedef enum {

@@ -214,6 +224,9 @@ int executableFlags = 0;

 /* Map of buffer for already reported exceptions to prevent re-reporting */

 T_jthreadMap *threadMap;

+/* Map of uncaught exceptions. There should be only 1 per thread.*/

+T_jthreadMap *uncaughtExceptionMap;

+

 /* forward headers */

 static char* get_path_to_class(jvmtiEnv *jvmti_env, JNIEnv *jni_env, jclass class, char *class_name, const char *stringize_method_name);

@@ -453,9 +466,12 @@ static int exception_is_intended_to_be_reported(

     if (reportedCaughExceptionTypes != NULL)

     {

-        *exception_type = get_exception_type_name(jvmti_env, jni_env, exception_object);

         if (NULL == *exception_type)

-            return 0;

+        {

+            *exception_type = get_exception_type_name(jvmti_env, jni_env, exception_object);

+            if (NULL == *exception_type)

+                return 0;

+        }

         /* special cases for selected exceptions */

         for (char **cursor = reportedCaughExceptionTypes; *cursor; ++cursor)

@@ -1277,7 +1293,7 @@ static void JNICALL callback_on_thread_start(

         return;

     }

-    jthread_map_push(threadMap, tid, threads_exc_buf);

+    jthread_map_push(threadMap, tid, (void *)threads_exc_buf);

 }

@@ -1304,7 +1320,25 @@ static void JNICALL callback_on_thread_end(

         return;

     }

-    T_jthrowableCircularBuf *threads_exc_buf = jthread_map_pop(threadMap, tid);

+    T_exceptionReport *rpt = (T_exceptionReport *)jthread_map_pop(uncaughtExceptionMap, tid);

+    T_jthrowableCircularBuf *threads_exc_buf = (T_jthrowableCircularBuf *)jthread_map_pop(threadMap, tid);

+

+    if (NULL != rpt)

+    {

+        if (NULL == threads_exc_buf || NULL == jthrowable_circular_buf_find(threads_exc_buf, rpt->exception_object))

+        {

+            report_stacktrace(NULL != rpt->executable ? rpt->executable : processProperties.main_class,

+                              NULL != rpt->message ? rpt->message : "Uncaught exception",

+                              rpt->stacktrace,

+                              NULL != threads_exc_buf);

+        }

+

+        free(rpt->message);

+        free(rpt->stacktrace);

+        free(rpt->executable);

+        free(rpt->exception_type_name);

+    }

+

     if (threads_exc_buf != NULL)

     {

         jthrowable_circular_buf_free(threads_exc_buf);

@@ -2120,7 +2154,7 @@ static void JNICALL callback_on_exception(

         if (NULL != threadMap && 0 == get_tid(jni_env, thr, &tid))

         {

-            threads_exc_buf = jthread_map_get(threadMap, tid);

+            threads_exc_buf = (T_jthrowableCircularBuf *)jthread_map_get(threadMap, tid);

             VERBOSE_PRINT("Got circular buffer for thread %p\n", (void *)threads_exc_buf);

         }

         else

@@ -2137,12 +2171,6 @@ static void JNICALL callback_on_exception(

             char *class_name_ptr = NULL;

             char *class_signature_ptr = NULL;

-            if (NULL != threads_exc_buf)

-            {

-                VERBOSE_PRINT("Pushing to circular buffer\n");

-                jthrowable_circular_buf_push(threads_exc_buf, exception_object);

-            }

-

             error_code = (*jvmti_env)->GetMethodName(jvmti_env, method, &method_name_ptr, &method_signature_ptr, NULL);

             if (check_jvmti_error(jvmti_env, error_code, __FILE__ ":" STRINGIZE(__LINE__)))

                 goto callback_on_exception_cleanup;

@@ -2176,11 +2204,47 @@ static void JNICALL callback_on_exception(

             if (NULL == report_message)

                 report_message = (NULL != catch_method) ? "Caught exception" : "Uncaught exception";

-            report_stacktrace(NULL != executable ? executable : processProperties.main_class,

-                    report_message,

-                    stack_trace_str,

-                    NULL != threads_exc_buf);

+            if (NULL == catch_method)

+            {   /* Postpone reporting of uncaught exceptions as they may be caught by a native function */

+                T_exceptionReport *rpt = malloc(sizeof(*rpt));

+                if (NULL == rpt)

+                {

+                    fprintf(stderr, __FILE__ ":" STRINGIZE(__LINE__) ": malloc(): out of memory");

+                }

+                else

+                {

+                    rpt->message = message;

+                    message = NULL;

+

+                    rpt->exception_type_name = exception_type_name;

+                    exception_type_name = NULL;

+

+                    rpt->stacktrace = stack_trace_str;

+                    stack_trace_str = NULL;

+

+                    rpt->executable = executable;

+                    executable = NULL;

+                    rpt->exception_object = exception_object;

+

+                    jthread_map_push(uncaughtExceptionMap, tid, (T_exceptionReport *)rpt);

+                }

+            }

+            else

+            {

+                report_stacktrace(NULL != executable ? executable : processProperties.main_class,

+                        report_message,

+                        stack_trace_str,

+                        NULL != threads_exc_buf);

+

+                if (NULL != threads_exc_buf)

+                {

+                    VERBOSE_PRINT("Pushing to circular buffer\n");

+                    jthrowable_circular_buf_push(threads_exc_buf, exception_object);

+                }

+            }

+

+            free(executable);

             free(message);

             free(stack_trace_str);

@@ -2217,18 +2281,16 @@ callback_on_exception_cleanup:

 }

-

-#if ABRT_EXCEPTION_CATCH_CHECK

 /*

  * This function is called when an exception is catched.

  */

 static void JNICALL callback_on_exception_catch(

             jvmtiEnv *jvmti_env,

-            JNIEnv   *jni_env __UNUSED_VAR,

-            jthread   thr __UNUSED_VAR,

+            JNIEnv   *jni_env,

+            jthread   thread,

             jmethodID method,

             jlocation location __UNUSED_VAR,

-            jobject   exception __UNUSED_VAR)

+            jobject   exception_object)

 {

     jvmtiError error_code;

@@ -2236,52 +2298,120 @@ static void JNICALL callback_on_exception_catch(

     char *method_signature_ptr = NULL;

     char *class_signature_ptr = NULL;

-    jclass class;

-

     /* all operations should be processed in critical section */

     enter_critical_section(jvmti_env, shared_lock);

-    /* retrieve all required informations */

-    error_code = (*jvmti_env)->GetMethodName(jvmti_env, method, &method_name_ptr, &method_signature_ptr, NULL);

-    if (check_jvmti_error(jvmti_env, error_code, __FILE__ ":" STRINGIZE(__LINE__)))

-        goto callback_on_exception_catch_cleanup;

-

-    error_code = (*jvmti_env)->GetMethodDeclaringClass(jvmti_env, method, &class);

-    if (check_jvmti_error(jvmti_env, error_code, __FILE__ ":" STRINGIZE(__LINE__)))

-        goto callback_on_exception_catch_cleanup;

+    jclass class;

-    error_code = (*jvmti_env)->GetClassSignature(jvmti_env, class, &class_signature_ptr, NULL);

-    if (check_jvmti_error(jvmti_env, error_code, __FILE__ ":" STRINGIZE(__LINE__)))

-        goto callback_on_exception_catch_cleanup;

+    jlong tid = 0;

-#ifdef VERBOSE

-    /* readable class name */

-    char *class_name_ptr = format_class_name(class_signature_ptr, '.');

-#endif

+    if (get_tid(jni_env, thread, &tid))

+    {

+        fprintf(stderr, __FILE__ ":" STRINGIZE(__LINE__) ": Cannot clear uncaught exceptions");

+        goto callback_on_exception_catch_exit;

+    }

-    VERBOSE_PRINT("An exception was caught in a method %s%s() with signature %s\n", class_name_ptr, method_name_ptr, method_signature_ptr);

+    T_exceptionReport *rpt = (T_exceptionReport *)jthread_map_get(uncaughtExceptionMap, tid);

+    if (NULL == rpt)

+    {

+        goto callback_on_exception_catch_exit;

+    }

-callback_on_exception_catch_cleanup:

-    /* cleapup */

-    if (method_name_ptr != NULL)

+    jclass object_class = (*jni_env)->FindClass(jni_env, "java/lang/Object");

+    if (NULL == object_class)

     {

-        error_code = (*jvmti_env)->Deallocate(jvmti_env, (unsigned char *)method_name_ptr);

-        check_jvmti_error(jvmti_env, error_code, __FILE__ ":" STRINGIZE(__LINE__));

+        VERBOSE_PRINT("Cannot find java/lang/Object class");

+        goto callback_on_exception_catch_exit;

     }

-    if (method_signature_ptr != NULL)

+

+    jmethodID equal_method = (*jni_env)->GetMethodID(jni_env, object_class, "equals", "(Ljava/lang/Object;)Z");

+    if (NULL == equal_method)

     {

-        error_code = (*jvmti_env)->Deallocate(jvmti_env, (unsigned char *)method_signature_ptr);

-        check_jvmti_error(jvmti_env, error_code, __FILE__ ":" STRINGIZE(__LINE__));

+        VERBOSE_PRINT("Cannot find java.lang.Object.equals(Ljava/lang/Object;)Z method");

+        (*jni_env)->DeleteLocalRef(jni_env, object_class);

+        goto callback_on_exception_catch_exit;

     }

-    if (class_signature_ptr != NULL)

+

+    jboolean equal_objects = (*jni_env)->CallBooleanMethod(jni_env, exception_object, equal_method, rpt->exception_object);

+    if (!equal_objects)

+        goto callback_on_exception_catch_exit;

+

+    /* Faster than get()-pop() approach is faster because it is search-and-search-free but

+     * pop()-push() approach is search-free-and-search-malloc

+     *

+     * JVM always catches java.security.PrivilegedActionException while

+     * handling uncaught java.lang.ClassNotFoundException throw by

+     * initialization of the system (native) class loader.

+     */

+    jthread_map_pop(uncaughtExceptionMap, tid);

+

+    if (exception_is_intended_to_be_reported(jvmti_env, jni_env, rpt->exception_object, &(rpt->exception_type_name)))

     {

-        error_code = (*jvmti_env)->Deallocate(jvmti_env, (unsigned char *)class_signature_ptr);

-        check_jvmti_error(jvmti_env, error_code, __FILE__ ":" STRINGIZE(__LINE__));

+        jlong tid = 0;

+        T_jthrowableCircularBuf *threads_exc_buf = NULL;

+

+        if (NULL != threadMap && 0 == get_tid(jni_env, thread, &tid))

+        {

+            threads_exc_buf = (T_jthrowableCircularBuf *)jthread_map_get(threadMap, tid);

+            VERBOSE_PRINT("Got circular buffer for thread %p\n", (void *)threads_exc_buf);

+        }

+        else

+        {

+            VERBOSE_PRINT("Cannot get thread's ID. Disabling reporting to ABRT.");

+        }

+

+        if (NULL == threads_exc_buf || NULL == jthrowable_circular_buf_find(threads_exc_buf, rpt->exception_object))

+        {

+            /* retrieve all required informations */

+            error_code = (*jvmti_env)->GetMethodName(jvmti_env, method, &method_name_ptr, &method_signature_ptr, NULL);

+            if (check_jvmti_error(jvmti_env, error_code, __FILE__ ":" STRINGIZE(__LINE__)))

+                goto callback_on_exception_catch_cleanup;

+

+            error_code = (*jvmti_env)->GetMethodDeclaringClass(jvmti_env, method, &class);

+            if (check_jvmti_error(jvmti_env, error_code, __FILE__ ":" STRINGIZE(__LINE__)))

+                goto callback_on_exception_catch_cleanup;

+

+            error_code = (*jvmti_env)->GetClassSignature(jvmti_env, class, &class_signature_ptr, NULL);

+            if (check_jvmti_error(jvmti_env, error_code, __FILE__ ":" STRINGIZE(__LINE__)))

+                goto callback_on_exception_catch_cleanup;

+

+            /* readable class name */

+            char *class_name_ptr = format_class_name(class_signature_ptr, '\0');

+            char *message = format_exception_reason_message(/*caught*/1, rpt->exception_type_name,  class_name_ptr, method_name_ptr);

+            report_stacktrace(NULL != rpt->executable ? rpt->executable : processProperties.main_class,

+                              NULL != message ? message : "Caught exception",

+                              rpt->stacktrace,

+                              NULL != threads_exc_buf);

+

+            if (NULL != threads_exc_buf)

+            {

+                VERBOSE_PRINT("Pushing to circular buffer\n");

+                jthrowable_circular_buf_push(threads_exc_buf, rpt->exception_object);

+            }

+

+callback_on_exception_catch_cleanup:

+            /* cleapup */

+            if (method_name_ptr != NULL)

+            {

+                error_code = (*jvmti_env)->Deallocate(jvmti_env, (unsigned char *)method_name_ptr);

+                check_jvmti_error(jvmti_env, error_code, __FILE__ ":" STRINGIZE(__LINE__));

+            }

+            if (class_signature_ptr != NULL)

+            {

+                error_code = (*jvmti_env)->Deallocate(jvmti_env, (unsigned char *)class_signature_ptr);

+                check_jvmti_error(jvmti_env, error_code, __FILE__ ":" STRINGIZE(__LINE__));

+            }

+        }

     }

+    free(rpt->message);

+    free(rpt->stacktrace);

+    free(rpt->executable);

+    free(rpt->exception_type_name);

+

+callback_on_exception_catch_exit:

     exit_critical_section(jvmti_env, shared_lock);

 }

-#endif /* ABRT_EXCEPTION_CATCH_CHECK */

@@ -2497,10 +2627,8 @@ jvmtiError register_all_callback_functions(jvmtiEnv *jvmti_env)

     /* JVMTI_EVENT_EXCEPTION */

     callbacks.Exception = &callback_on_exception;

-#if ABRT_EXCEPTION_CATCH_CHECK

     /* JVMTI_EVENT_EXCEPTION_CATCH */

     callbacks.ExceptionCatch = &callback_on_exception_catch;

-#endif /* ABRT_EXCEPTION_CATCH_CHECK */

 #if ABRT_OBJECT_ALLOCATION_SIZE_CHECK

     /* JVMTI_EVENT_VM_OBJECT_ALLOC */

@@ -2580,12 +2708,10 @@ jvmtiError set_event_notification_modes(jvmtiEnv* jvmti_env)

         return error_code;

     }

-#if ABRT_EXCEPTION_CATCH_CHECK

     if ((error_code = set_event_notification_mode(jvmti_env, JVMTI_EVENT_EXCEPTION_CATCH)) != JNI_OK)

     {

         return error_code;

     }

-#endif /* ABRT_EXCEPTION_CATCH_CHECK */

 #if ABRT_OBJECT_ALLOCATION_SIZE_CHECK

     if ((error_code = set_event_notification_mode(jvmti_env, JVMTI_EVENT_VM_OBJECT_ALLOC)) != JNI_OK)

@@ -2903,6 +3029,12 @@ JNIEXPORT jint JNICALL Agent_OnLoad(

         return -1;

     }

+    uncaughtExceptionMap = jthread_map_new();

+    if (NULL == uncaughtExceptionMap)

+    {

+        fprintf(stderr, __FILE__ ":" STRINGIZE(__LINE__) ": can not create a set of uncaught exceptions\n");

+        return -1;

+    }

     return JNI_OK;

 }

@@ -2928,6 +3060,7 @@ JNIEXPORT void JNICALL Agent_OnUnload(JavaVM *vm __UNUSED_VAR)

         fclose(fout);

     }

+    jthread_map_free(uncaughtExceptionMap);

     jthread_map_free(threadMap);

 }

diff --git a/src/jthread_map.c b/src/jthread_map.c

index 29c5c29..cd5ca52 100644

--- a/src/jthread_map.c

+++ b/src/jthread_map.c

@@ -35,7 +35,7 @@ struct jthread_map_item;

 typedef struct jthread_map_item {

     long tid;                         ///< item ID from Thread.getId()

-    T_jthrowableCircularBuf *buffer;  ///< an instance of circular buffer for thread

+    void *data;                       ///< data

     struct jthread_map_item *next;    ///< a next item mapped to same element

 } T_jthreadMapItem;

@@ -76,7 +76,7 @@ void jthread_map_free(T_jthreadMap *map)

-static T_jthreadMapItem *jthrowable_map_item_new(long tid, T_jthrowableCircularBuf *buffer)

+static T_jthreadMapItem *jthrowable_map_item_new(long tid, void *item)

 {

     T_jthreadMapItem *itm = malloc(sizeof(*itm));

     if (NULL == itm)

@@ -86,7 +86,7 @@ static T_jthreadMapItem *jthrowable_map_item_new(long tid, T_jthrowableCircularB

     }

     itm->tid = tid;

-    itm->buffer = buffer;

+    itm->data = item;

     itm->next = NULL;

     return itm;

 }

@@ -105,7 +105,7 @@ static void jthread_map_item_free(T_jthreadMapItem *itm)

-void jthread_map_push(T_jthreadMap *map, jlong tid, T_jthrowableCircularBuf *buffer)

+void jthread_map_push(T_jthreadMap *map, jlong tid, void *item)

 {

     assert(NULL != map);

@@ -122,7 +122,7 @@ void jthread_map_push(T_jthreadMap *map, jlong tid, T_jthrowableCircularBuf *buf

     if (NULL == itm)

     {

-        T_jthreadMapItem *new = jthrowable_map_item_new(tid, buffer);

+        T_jthreadMapItem *new = jthrowable_map_item_new(tid, item);

         if (last == NULL)

         {

             map->items[index] = new;

@@ -138,39 +138,39 @@ void jthread_map_push(T_jthreadMap *map, jlong tid, T_jthrowableCircularBuf *buf

-T_jthrowableCircularBuf *jthread_map_get(T_jthreadMap *map, jlong tid)

+void *jthread_map_get(T_jthreadMap *map, jlong tid)

 {

     assert(NULL != map);

     pthread_mutex_lock(&map->mutex);

     const size_t index = tid % MAP_SIZE;

-    T_jthrowableCircularBuf *buffer = NULL;

+    void *data = NULL;

     for (T_jthreadMapItem *itm = map->items[index]; NULL != itm; itm = itm->next)

     {

         if (itm->tid == tid)

         {

-            buffer = itm->buffer;

+            data = itm->data;

             break;

         }

     }

     pthread_mutex_unlock(&map->mutex);

-    return buffer;

+    return data;

 }

-T_jthrowableCircularBuf *jthread_map_pop(T_jthreadMap *map, jlong tid)

+void *jthread_map_pop(T_jthreadMap *map, jlong tid)

 {

     assert(NULL != map);

     pthread_mutex_lock(&map->mutex);

     const size_t index = tid % MAP_SIZE;

-    T_jthrowableCircularBuf *buffer = NULL;

+    void *data = NULL;

     if (NULL != map->items[index])

     {

         T_jthreadMapItem *last = NULL;

@@ -183,7 +183,7 @@ T_jthrowableCircularBuf *jthread_map_pop(T_jthreadMap *map, jlong tid)

         if (NULL != itm)

         {

-            buffer = itm->buffer;

+            data = itm->data;

             if (NULL == last)

             {

@@ -200,7 +200,7 @@ T_jthrowableCircularBuf *jthread_map_pop(T_jthreadMap *map, jlong tid)

     pthread_mutex_unlock(&map->mutex);

-    return buffer;

+    return data;

 }

diff --git a/src/jthread_map.h b/src/jthread_map.h

index 29fcc92..52d2832 100644

--- a/src/jthread_map.h

+++ b/src/jthread_map.h

@@ -23,7 +23,7 @@

 /*

- * Map of TID to jthrowable_circular_buf

+ * Map of TID to (void *)

  */

 typedef struct jthread_map T_jthreadMap;

@@ -41,7 +41,7 @@ T_jthreadMap *jthread_map_new();

 /*

  * Frees map's memory

  *

- * Doesn't release memory of stored circular buffers.

+ * Doesn't release memory of stored (void *).

  *

  * @param map Pointer to @jthread_map. Accepts NULL

  */

@@ -50,15 +50,15 @@ void jthread_map_free(T_jthreadMap *map);

 /*

- * Adds a new map item identified by @tid with value @buffer

+ * Adds a new map item identified by @tid with value @item

  *

  * Does nothing if item with same @tid already exists in @map

  *

  * @param map Map

  * @param tid New item ID

- * @param buffer A pointer to @jthrowable_circular_buf

+ * @param item A (void *) item

  */

-void jthread_map_push(T_jthreadMap *map, jlong tid, T_jthrowableCircularBuf *buffer);

+void jthread_map_push(T_jthreadMap *map, jlong tid, void *item);

@@ -67,9 +67,9 @@ void jthread_map_push(T_jthreadMap *map, jlong tid, T_jthrowableCircularBuf *buf

  *

  * @param map Map

  * @param tid Required ID

- * @returns A pointer to stored @jthrowable_circular_buf or NULL if item with @tid was not found

+ * @returns A stored item or NULL if item with @tid was not found

  */

-T_jthrowableCircularBuf *jthread_map_get(T_jthreadMap *map, jlong tid);

+void *jthread_map_get(T_jthreadMap *map, jlong tid);

@@ -78,9 +78,9 @@ T_jthrowableCircularBuf *jthread_map_get(T_jthreadMap *map, jlong tid);

  *

  * @param map Map

  * @param tid Removed item's ID

- * @returns A pointer to stored @jthrowable_circular_buf or NULL if item with @tid was not found

+ * @returns A stored item or NULL if item with @tid was not found

  */

-T_jthrowableCircularBuf *jthread_map_pop(T_jthreadMap *map, jlong tid);

+void *jthread_map_pop(T_jthreadMap *map, jlong tid);

-- 

1.8.3.1