Wed Feb 1 18:23:55 CET 2006 Paolo Molaro <lupus@ximian.com>

	* pthread_support.c, *: back out Zoltan's patch since it's
	incorrect.
	The correct fix it to execute the cleanup from inside
	the thread also when using the __thread var to access the
	current GC_thread.

svn path=/trunk/mono/; revision=56400

diff --git a/ChangeLog b/ChangeLog
index 8c47519f14dc191c4d23152b0b2a48b79c20e0db..9e8995ccf8d7e090508e5474c2c512e067adb356 100644 (file)
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,12 @@
+
+Wed Feb 1 18:23:55 CET 2006 Paolo Molaro <lupus@ximian.com>
+
+       * pthread_support.c, *: back out Zoltan's patch since it's
+       incorrect.
+       The correct fix it to execute the cleanup from inside
+       the thread also when using the __thread var to access the
+       current GC_thread.
+
 2006-02-01  Zoltan Varga  <vargaz@gmail.com>
 
        * pthread_support.c (GC_thread_deregister_foreign): New public API

diff --git a/include/private/pthread_support.h b/include/private/pthread_support.h
index b4a762b542cbdb831c27e688278bff433ea591ca..c2c48c22e01a2c889f0d2f3d8a092d07777f20fd 100644 (file)
--- a/include/private/pthread_support.h
+++ b/include/private/pthread_support.h
@@ -92,7 +92,7 @@ extern GC_bool GC_thr_initialized;
 
 GC_thread GC_lookup_thread(pthread_t id);
 
-void GC_thread_deregister_foreign (void);
+void GC_thread_deregister_foreign (void *data);
 
 void GC_stop_init();
 

diff --git a/pthread_support.c b/pthread_support.c
index 5a7b37692089910f86ee5dcf0f0223fb966975ef..7101e4e7362de6e1e7e69648be41511a5a33ba82 100644 (file)
--- a/pthread_support.c
+++ b/pthread_support.c
@@ -84,6 +84,12 @@
 #   if !defined(USE_PTHREAD_SPECIFIC) && !defined(USE_COMPILER_TLS)
 #     include "private/specific.h"
 #   endif
+
+/* Note that these macros should be used only to get/set the GC_thread pointer.
+ * We need to use both tls and pthread because we use the pthread_create function hook to
+ * free the data for foreign threads. When that doesn't happen, libgc could have old
+ * pthread_t that get reused...
+ */
 #   if defined(USE_PTHREAD_SPECIFIC)
 #     define GC_getspecific pthread_getspecific
 #     define GC_setspecific pthread_setspecific
@@ -91,9 +97,9 @@
       typedef pthread_key_t GC_key_t;
 #   endif
 #   if defined(USE_COMPILER_TLS)
-#     define GC_getspecific(x) (x)
-#     define GC_setspecific(key, v) ((key) = (v), 0)
-#     define GC_key_create(key, d) 0
+#     define GC_getspecific(x) (GC_thread_tls)
+#     define GC_setspecific(key, v) (GC_thread_tls = (v), pthread_setspecific ((key), (v)))
+#     define GC_key_create pthread_key_create
       typedef void * GC_key_t;
 #   endif
 # endif
@@ -177,10 +183,11 @@ void GC_init_parallel();
 #include "mono/utils/mono-compiler.h"
 
 static
+GC_key_t GC_thread_key;
+
 #ifdef USE_COMPILER_TLS
-  __thread MONO_TLS_FAST
+static __thread MONO_TLS_FAST void* GC_thread_tls;
 #endif
-GC_key_t GC_thread_key;
 
 static GC_bool keys_initialized;
 
@@ -221,17 +228,19 @@ static void return_freelists(ptr_t *fl, ptr_t *gfl)
 /* we arrange for those to fault asap.)                                        */
 static ptr_t size_zero_object = (ptr_t)(&size_zero_object);
 
-void GC_delete_thread(pthread_t id);
+void GC_delete_gc_thread(pthread_t id, GC_thread gct);
 
-/* Called by pthreads when the TLS entry is destroyed */
-static void GC_thread_deregister_foreign_internal (void *data)
+void GC_thread_deregister_foreign (void *data)
 {
     GC_thread me = (GC_thread)data;
  /*   GC_fprintf1( "\n\n\n\n --- Deregister %x ---\n\n\n\n\n", me->flags ); */
     if (me -> flags & FOREIGN_THREAD) {
        LOCK();
  /*    GC_fprintf0( "\n\n\n\n --- FOO ---\n\n\n\n\n" ); */
-       GC_delete_thread(me->id);
+#if defined(THREAD_LOCAL_ALLOC) && !defined(DBG_HDRS_ALL)
+       GC_destroy_thread_local (me);
+#endif
+       GC_delete_gc_thread(me->id, me);
        UNLOCK();
     }
 }
@@ -244,7 +253,7 @@ void GC_init_thread_local(GC_thread p)
     int i;
 
     if (!keys_initialized) {
-       if (0 != GC_key_create(&GC_thread_key, GC_thread_deregister_foreign_internal)) {
+       if (0 != GC_key_create(&GC_thread_key, GC_thread_deregister_foreign)) {
            ABORT("Failed to create key for local allocator");
         }
        keys_initialized = TRUE;
@@ -284,7 +293,6 @@ void GC_destroy_thread_local(GC_thread p)
 #   ifdef GC_GCJ_SUPPORT
        return_freelists(p -> gcj_freelists, GC_gcjobjfreelist);
 #   endif
-    GC_setspecific(GC_thread_key, NULL);
 }
 
 extern GC_PTR GC_generic_malloc_many();
@@ -632,7 +640,7 @@ void GC_delete_thread(pthread_t id)
     int hv = ((word)id) % THREAD_TABLE_SZ;
     register GC_thread p = GC_threads[hv];
     register GC_thread prev = 0;
-
+    
     while (!pthread_equal(p -> id, id)) {
         prev = p;
         p = p -> next;
@@ -1262,21 +1270,6 @@ int GC_thread_register_foreign (void *base_addr)
     return me != NULL;
 }
 
-void GC_thread_deregister_foreign (void)
-{
-       GC_thread me;
-
-       LOCK ();
-       me = GC_lookup_thread (pthread_self ());
-       if (me->flags & FOREIGN_THREAD) {
-               GC_delete_thread (me->id);
-#if defined(THREAD_LOCAL_ALLOC) && !defined(DBG_HDRS_ALL)
-               GC_destroy_thread_local (me);
-#endif
-       }
-       UNLOCK ();
-}
-
 void * GC_start_routine(void * arg)
 {
     int dummy;

diff --git a/solaris_threads.c b/solaris_threads.c
index a2f0a5d2aa1d0e0436b509c27ef9f093472264f0..5c49c1206b8176d85a09aa1fa7f33ca2ebf1e56a 100644 (file)
--- a/solaris_threads.c
+++ b/solaris_threads.c
@@ -641,10 +641,6 @@ int GC_thread_register_foreign (void *base_addr)
        return 0;
 }
 
-void GC_thread_deregister_foreign (void)
-{
-}
-
 /* Solaris 2/Intel uses an initial stack size limit slightly bigger than the
    SPARC default of 8 MB.  Account for this to warn only if the user has
    raised the limit beyond the default.