mono/metadata/gc.c

   1 /*
   2  * metadata/gc.c: GC icalls.
   3  *
   4  * Author: Paolo Molaro <lupus@ximian.com>
   5  *
   6  * Copyright 2002-2003 Ximian, Inc (http://www.ximian.com)
   7  * Copyright 2004-2009 Novell, Inc (http://www.novell.com)
   8  * Copyright 2012 Xamarin Inc (http://www.xamarin.com)
   9  * Licensed under the MIT license. See LICENSE file in the project root for full license information.
  10  */
  11
  12 #include <config.h>
  13 #include <glib.h>
  14 #include <string.h>
  15
  16 #include <mono/metadata/gc-internals.h>
  17 #include <mono/metadata/mono-gc.h>
  18 #include <mono/metadata/threads.h>
  19 #include <mono/metadata/tabledefs.h>
  20 #include <mono/metadata/exception.h>
  21 #include <mono/metadata/profiler-private.h>
  22 #include <mono/metadata/domain-internals.h>
  23 #include <mono/metadata/class-internals.h>
  24 #include <mono/metadata/metadata-internals.h>
  25 #include <mono/metadata/mono-mlist.h>
  26 #include <mono/metadata/threads-types.h>
  27 #include <mono/metadata/threadpool-ms.h>
  28 #include <mono/sgen/sgen-conf.h>
  29 #include <mono/sgen/sgen-gc.h>
  30 #include <mono/utils/mono-logger-internals.h>
  31 #include <mono/metadata/gc-internals.h>
  32 #include <mono/metadata/marshal.h> /* for mono_delegate_free_ftnptr () */
  33 #include <mono/metadata/attach.h>
  34 #include <mono/metadata/console-io.h>
  35 #include <mono/utils/mono-os-semaphore.h>
  36 #include <mono/utils/mono-memory-model.h>
  37 #include <mono/utils/mono-counters.h>
  38 #include <mono/utils/mono-time.h>
  39 #include <mono/utils/dtrace.h>
  40 #include <mono/utils/mono-threads.h>
  41 #include <mono/utils/mono-threads-coop.h>
  42 #include <mono/utils/atomic.h>
  43 #include <mono/utils/mono-coop-semaphore.h>
  44 #include <mono/utils/hazard-pointer.h>
  45
  46 #ifndef HOST_WIN32
  47 #include <pthread.h>
  48 #endif
  49
  50 typedef struct DomainFinalizationReq {
  51         MonoDomain *domain;
  52         HANDLE done_event;
  53 } DomainFinalizationReq;
  54
  55 static gboolean gc_disabled = FALSE;
  56
  57 static gboolean finalizing_root_domain = FALSE;
  58
  59 gboolean log_finalizers = FALSE;
  60 gboolean mono_do_not_finalize = FALSE;
  61 gchar **mono_do_not_finalize_class_names = NULL;
  62
  63 #define mono_finalizer_lock() mono_coop_mutex_lock (&finalizer_mutex)
  64 #define mono_finalizer_unlock() mono_coop_mutex_unlock (&finalizer_mutex)
  65 static MonoCoopMutex finalizer_mutex;
  66 static MonoCoopMutex reference_queue_mutex;
  67
  68 static GSList *domains_to_finalize= NULL;
  69 static MonoMList *threads_to_finalize = NULL;
  70
  71 static gboolean finalizer_thread_exited;
  72 /* Uses finalizer_mutex */
  73 static MonoCoopCond exited_cond;
  74
  75 static MonoInternalThread *gc_thread;
  76
  77 static void object_register_finalizer (MonoObject *obj, void (*callback)(void *, void*));
  78
  79 static void reference_queue_proccess_all (void);
  80 static void mono_reference_queue_cleanup (void);
  81 static void reference_queue_clear_for_domain (MonoDomain *domain);
  82 static HANDLE pending_done_event;
  83
  84 static guint32
  85 guarded_wait (HANDLE handle, guint32 timeout, gboolean alertable)
  86 {
  87         guint32 result;
  88
  89         MONO_ENTER_GC_SAFE;
  90         result = WaitForSingleObjectEx (handle, timeout, alertable);
  91         MONO_EXIT_GC_SAFE;
  92
  93         return result;
  94 }
  95
  96 static gboolean
  97 add_thread_to_finalize (MonoInternalThread *thread, MonoError *error)
  98 {
  99         mono_error_init (error);
 100         mono_finalizer_lock ();
 101         if (!threads_to_finalize)
 102                 MONO_GC_REGISTER_ROOT_SINGLE (threads_to_finalize, MONO_ROOT_SOURCE_FINALIZER_QUEUE, "finalizable threads list");
 103         threads_to_finalize = mono_mlist_append_checked (threads_to_finalize, (MonoObject*)thread, error);
 104         mono_finalizer_unlock ();
 105         return is_ok (error);
 106 }
 107
 108 static volatile gboolean suspend_finalizers = FALSE;
 109 /*
 110  * actually, we might want to queue the finalize requests in a separate thread,
 111  * but we need to be careful about the execution domain of the thread...
 112  */
 113 void
 114 mono_gc_run_finalize (void *obj, void *data)
 115 {
 116         MonoError error;
 117         MonoObject *exc = NULL;
 118         MonoObject *o;
 119 #ifndef HAVE_SGEN_GC
 120         MonoObject *o2;
 121 #endif
 122         MonoMethod* finalizer = NULL;
 123         MonoDomain *caller_domain = mono_domain_get ();
 124         MonoDomain *domain;
 125         RuntimeInvokeFunction runtime_invoke;
 126
 127         // This function is called from the innards of the GC, so our best alternative for now is to do polling here
 128         mono_threads_safepoint ();
 129
 130         o = (MonoObject*)((char*)obj + GPOINTER_TO_UINT (data));
 131
 132         if (mono_do_not_finalize) {
 133                 if (!mono_do_not_finalize_class_names)
 134                         return;
 135
 136                 size_t namespace_len = strlen (o->vtable->klass->name_space);
 137                 for (int i = 0; mono_do_not_finalize_class_names [i]; ++i) {
 138                         const char *name = mono_do_not_finalize_class_names [i];
 139                         if (strncmp (name, o->vtable->klass->name_space, namespace_len))
 140                                 break;
 141                         if (name [namespace_len] != '.')
 142                                 break;
 143                         if (strcmp (name + namespace_len + 1, o->vtable->klass->name))
 144                                 break;
 145                         return;
 146                 }
 147         }
 148
 149         if (log_finalizers)
 150                 g_log ("mono-gc-finalizers", G_LOG_LEVEL_DEBUG, "<%s at %p> Starting finalizer checks.", o->vtable->klass->name, o);
 151
 152         if (suspend_finalizers)
 153                 return;
 154
 155         domain = o->vtable->domain;
 156
 157 #ifndef HAVE_SGEN_GC
 158         mono_domain_finalizers_lock (domain);
 159
 160         o2 = (MonoObject *)g_hash_table_lookup (domain->finalizable_objects_hash, o);
 161
 162         mono_domain_finalizers_unlock (domain);
 163
 164         if (!o2)
 165                 /* Already finalized somehow */
 166                 return;
 167 #endif
 168
 169         /* make sure the finalizer is not called again if the object is resurrected */
 170         object_register_finalizer ((MonoObject *)obj, NULL);
 171
 172         if (log_finalizers)
 173                 g_log ("mono-gc-finalizers", G_LOG_LEVEL_MESSAGE, "<%s at %p> Registered finalizer as processed.", o->vtable->klass->name, o);
 174
 175         if (o->vtable->klass == mono_defaults.internal_thread_class) {
 176                 MonoInternalThread *t = (MonoInternalThread*)o;
 177
 178                 if (mono_gc_is_finalizer_internal_thread (t))
 179                         /* Avoid finalizing ourselves */
 180                         return;
 181
 182                 if (t->threadpool_thread && finalizing_root_domain) {
 183                         /* Don't finalize threadpool threads when
 184                            shutting down - they're finalized when the
 185                            threadpool shuts down. */
 186                         if (!add_thread_to_finalize (t, &error))
 187                                 goto unhandled_error;
 188                         return;
 189                 }
 190         }
 191
 192         if (o->vtable->klass->image == mono_defaults.corlib && !strcmp (o->vtable->klass->name, "DynamicMethod") && finalizing_root_domain) {
 193                 /*
 194                  * These can't be finalized during unloading/shutdown, since that would
 195                  * free the native code which can still be referenced by other
 196                  * finalizers.
 197                  * FIXME: This is not perfect, objects dying at the same time as
 198                  * dynamic methods can still reference them even when !shutdown.
 199                  */
 200                 return;
 201         }
 202
 203         if (mono_runtime_get_no_exec ())
 204                 return;
 205
 206         /* speedup later... and use a timeout */
 207         /* g_print ("Finalize run on %p %s.%s\n", o, mono_object_class (o)->name_space, mono_object_class (o)->name); */
 208
 209         /* Use _internal here, since this thread can enter a doomed appdomain */
 210         mono_domain_set_internal (mono_object_domain (o));
 211
 212         /* delegates that have a native function pointer allocated are
 213          * registered for finalization, but they don't have a Finalize
 214          * method, because in most cases it's not needed and it's just a waste.
 215          */
 216         if (o->vtable->klass->delegate) {
 217                 MonoDelegate* del = (MonoDelegate*)o;
 218                 if (del->delegate_trampoline)
 219                         mono_delegate_free_ftnptr ((MonoDelegate*)o);
 220                 mono_domain_set_internal (caller_domain);
 221                 return;
 222         }
 223
 224         finalizer = mono_class_get_finalizer (o->vtable->klass);
 225
 226         /* If object has a CCW but has no finalizer, it was only
 227          * registered for finalization in order to free the CCW.
 228          * Else it needs the regular finalizer run.
 229          * FIXME: what to do about ressurection and suppression
 230          * of finalizer on object with CCW.
 231          */
 232         if (mono_marshal_free_ccw (o) && !finalizer) {
 233                 mono_domain_set_internal (caller_domain);
 234                 return;
 235         }
 236
 237         /*
 238          * To avoid the locking plus the other overhead of mono_runtime_invoke_checked (),
 239          * create and precompile a wrapper which calls the finalize method using
 240          * a CALLVIRT.
 241          */
 242         if (log_finalizers)
 243                 g_log ("mono-gc-finalizers", G_LOG_LEVEL_MESSAGE, "<%s at %p> Compiling finalizer.", o->vtable->klass->name, o);
 244
 245         if (!domain->finalize_runtime_invoke) {
 246                 MonoMethod *invoke = mono_marshal_get_runtime_invoke (mono_class_get_method_from_name_flags (mono_defaults.object_class, "Finalize", 0, 0), TRUE);
 247
 248                 domain->finalize_runtime_invoke = mono_compile_method_checked (invoke, &error);
 249                 mono_error_assert_ok (&error); /* expect this not to fail */
 250         }
 251
 252         runtime_invoke = (RuntimeInvokeFunction)domain->finalize_runtime_invoke;
 253
 254         mono_runtime_class_init_full (o->vtable, &error);
 255         if (!is_ok (&error))
 256                 goto unhandled_error;
 257
 258         if (G_UNLIKELY (MONO_GC_FINALIZE_INVOKE_ENABLED ())) {
 259                 MONO_GC_FINALIZE_INVOKE ((unsigned long)o, mono_object_get_size (o),
 260                                 o->vtable->klass->name_space, o->vtable->klass->name);
 261         }
 262
 263         if (log_finalizers)
 264                 g_log ("mono-gc-finalizers", G_LOG_LEVEL_MESSAGE, "<%s at %p> Calling finalizer.", o->vtable->klass->name, o);
 265
 266         runtime_invoke (o, NULL, &exc, NULL);
 267
 268         if (log_finalizers)
 269                 g_log ("mono-gc-finalizers", G_LOG_LEVEL_MESSAGE, "<%s at %p> Returned from finalizer.", o->vtable->klass->name, o);
 270
 271 unhandled_error:
 272         if (!is_ok (&error))
 273                 exc = (MonoObject*)mono_error_convert_to_exception (&error);
 274         if (exc)
 275                 mono_thread_internal_unhandled_exception (exc);
 276
 277         mono_domain_set_internal (caller_domain);
 278 }
 279
 280 void
 281 mono_gc_finalize_threadpool_threads (void)
 282 {
 283         while (threads_to_finalize) {
 284                 MonoInternalThread *thread = (MonoInternalThread*) mono_mlist_get_data (threads_to_finalize);
 285
 286                 /* Force finalization of the thread. */
 287                 thread->threadpool_thread = FALSE;
 288                 mono_object_register_finalizer ((MonoObject*)thread);
 289
 290                 mono_gc_run_finalize (thread, NULL);
 291
 292                 threads_to_finalize = mono_mlist_next (threads_to_finalize);
 293         }
 294 }
 295
 296 gpointer
 297 mono_gc_out_of_memory (size_t size)
 298 {
 299         /*
 300          * we could allocate at program startup some memory that we could release
 301          * back to the system at this point if we're really low on memory (ie, size is
 302          * lower than the memory we set apart)
 303          */
 304         mono_raise_exception (mono_domain_get ()->out_of_memory_ex);
 305
 306         return NULL;
 307 }
 308
 309 /*
 310  * Some of our objects may point to a different address than the address returned by GC_malloc()
 311  * (because of the GetHashCode hack), but we need to pass the real address to register_finalizer.
 312  * This also means that in the callback we need to adjust the pointer to get back the real
 313  * MonoObject*.
 314  * We also need to be consistent in the use of the GC_debug* variants of malloc and register_finalizer,
 315  * since that, too, can cause the underlying pointer to be offset.
 316  */
 317 static void
 318 object_register_finalizer (MonoObject *obj, void (*callback)(void *, void*))
 319 {
 320         MonoDomain *domain;
 321
 322         g_assert (obj != NULL);
 323
 324         domain = obj->vtable->domain;
 325
 326 #if HAVE_BOEHM_GC
 327         if (mono_domain_is_unloading (domain) && (callback != NULL))
 328                 /*
 329                  * Can't register finalizers in a dying appdomain, since they
 330                  * could be invoked after the appdomain has been unloaded.
 331                  */
 332                 return;
 333
 334         mono_domain_finalizers_lock (domain);
 335
 336         if (callback)
 337                 g_hash_table_insert (domain->finalizable_objects_hash, obj, obj);
 338         else
 339                 g_hash_table_remove (domain->finalizable_objects_hash, obj);
 340
 341         mono_domain_finalizers_unlock (domain);
 342
 343         mono_gc_register_for_finalization (obj, callback);
 344 #elif defined(HAVE_SGEN_GC)
 345         /*
 346          * If we register finalizers for domains that are unloading we might
 347          * end up running them while or after the domain is being cleared, so
 348          * the objects will not be valid anymore.
 349          */
 350         if (!mono_domain_is_unloading (domain))
 351                 mono_gc_register_for_finalization (obj, callback);
 352 #endif
 353 }
 354
 355 /**
 356  * mono_object_register_finalizer:
 357  * @obj: object to register
 358  *
 359  * Records that object @obj has a finalizer, this will call the
 360  * Finalize method when the garbage collector disposes the object.
 361  *
 362  */
 363 void
 364 mono_object_register_finalizer (MonoObject *obj)
 365 {
 366         /* g_print ("Registered finalizer on %p %s.%s\n", obj, mono_object_class (obj)->name_space, mono_object_class (obj)->name); */
 367         object_register_finalizer (obj, mono_gc_run_finalize);
 368 }
 369
 370 /**
 371  * mono_domain_finalize:
 372  * @domain: the domain to finalize
 373  * @timeout: msects to wait for the finalization to complete, -1 to wait indefinitely
 374  *
 375  *  Request finalization of all finalizable objects inside @domain. Wait
 376  * @timeout msecs for the finalization to complete.
 377  *
 378  * Returns: TRUE if succeeded, FALSE if there was a timeout
 379  */
 380
 381 gboolean
 382 mono_domain_finalize (MonoDomain *domain, guint32 timeout)
 383 {
 384         DomainFinalizationReq *req;
 385         guint32 res;
 386         HANDLE done_event;
 387         MonoInternalThread *thread = mono_thread_internal_current ();
 388
 389 #if defined(__native_client__)
 390         return FALSE;
 391 #endif
 392
 393         if (mono_thread_internal_current () == gc_thread)
 394                 /* We are called from inside a finalizer, not much we can do here */
 395                 return FALSE;
 396
 397         /*
 398          * No need to create another thread 'cause the finalizer thread
 399          * is still working and will take care of running the finalizers
 400          */
 401
 402         if (gc_disabled)
 403                 return TRUE;
 404
 405         /* We don't support domain finalization without a GC */
 406         if (mono_gc_is_null ())
 407                 return FALSE;
 408
 409         mono_gc_collect (mono_gc_max_generation ());
 410
 411         done_event = CreateEvent (NULL, TRUE, FALSE, NULL);
 412         if (done_event == NULL) {
 413                 return FALSE;
 414         }
 415
 416         req = g_new0 (DomainFinalizationReq, 1);
 417         req->domain = domain;
 418         req->done_event = done_event;
 419
 420         if (domain == mono_get_root_domain ())
 421                 finalizing_root_domain = TRUE;
 422
 423         mono_finalizer_lock ();
 424
 425         domains_to_finalize = g_slist_append (domains_to_finalize, req);
 426
 427         mono_finalizer_unlock ();
 428
 429         /* Tell the finalizer thread to finalize this appdomain */
 430         mono_gc_finalize_notify ();
 431
 432         if (timeout == -1)
 433                 timeout = INFINITE;
 434
 435         while (TRUE) {
 436                 res = guarded_wait (done_event, timeout, TRUE);
 437                 /* printf ("WAIT RES: %d.\n", res); */
 438
 439                 if (res == WAIT_IO_COMPLETION) {
 440                         if ((thread->state & (ThreadState_StopRequested | ThreadState_SuspendRequested)) != 0)
 441                                 return FALSE;
 442                 } else if (res == WAIT_TIMEOUT) {
 443                         /* We leak the handle here */
 444                         return FALSE;
 445                 } else {
 446                         break;
 447                 }
 448         }
 449
 450         CloseHandle (done_event);
 451
 452         if (domain == mono_get_root_domain ()) {
 453                 mono_threadpool_ms_cleanup ();
 454                 mono_gc_finalize_threadpool_threads ();
 455         }
 456
 457         mono_profiler_appdomain_event (domain, MONO_PROFILE_END_UNLOAD);
 458
 459         return TRUE;
 460 }
 461
 462 void
 463 ves_icall_System_GC_InternalCollect (int generation)
 464 {
 465         mono_gc_collect (generation);
 466 }
 467
 468 gint64
 469 ves_icall_System_GC_GetTotalMemory (MonoBoolean forceCollection)
 470 {
 471         if (forceCollection)
 472                 mono_gc_collect (mono_gc_max_generation ());
 473         return mono_gc_get_used_size ();
 474 }
 475
 476 void
 477 ves_icall_System_GC_KeepAlive (MonoObject *obj)
 478 {
 479         /*
 480          * Does nothing.
 481          */
 482 }
 483
 484 void
 485 ves_icall_System_GC_ReRegisterForFinalize (MonoObject *obj)
 486 {
 487         MONO_CHECK_ARG_NULL (obj,);
 488
 489         object_register_finalizer (obj, mono_gc_run_finalize);
 490 }
 491
 492 void
 493 ves_icall_System_GC_SuppressFinalize (MonoObject *obj)
 494 {
 495         MONO_CHECK_ARG_NULL (obj,);
 496
 497         /* delegates have no finalizers, but we register them to deal with the
 498          * unmanaged->managed trampoline. We don't let the user suppress it
 499          * otherwise we'd leak it.
 500          */
 501         if (obj->vtable->klass->delegate)
 502                 return;
 503
 504         /* FIXME: Need to handle case where obj has COM Callable Wrapper
 505          * generated for it that needs cleaned up, but user wants to suppress
 506          * their derived object finalizer. */
 507
 508         object_register_finalizer (obj, NULL);
 509 }
 510
 511 void
 512 ves_icall_System_GC_WaitForPendingFinalizers (void)
 513 {
 514         if (mono_gc_is_null ())
 515                 return;
 516
 517         if (!mono_gc_pending_finalizers ())
 518                 return;
 519
 520         if (mono_thread_internal_current () == gc_thread)
 521                 /* Avoid deadlocks */
 522                 return;
 523
 524         /*
 525         If the finalizer thread is not live, lets pretend no finalizers are pending since the current thread might
 526         be the one responsible for starting it up.
 527         */
 528         if (gc_thread == NULL)
 529                 return;
 530
 531         ResetEvent (pending_done_event);
 532         mono_gc_finalize_notify ();
 533         /* g_print ("Waiting for pending finalizers....\n"); */
 534         guarded_wait (pending_done_event, INFINITE, TRUE);
 535         /* g_print ("Done pending....\n"); */
 536 }
 537
 538 void
 539 ves_icall_System_GC_register_ephemeron_array (MonoObject *array)
 540 {
 541 #ifdef HAVE_SGEN_GC
 542         if (!mono_gc_ephemeron_array_add (array)) {
 543                 mono_set_pending_exception (mono_object_domain (array)->out_of_memory_ex);
 544                 return;
 545         }
 546 #endif
 547 }
 548
 549 MonoObject*
 550 ves_icall_System_GC_get_ephemeron_tombstone (void)
 551 {
 552         return mono_domain_get ()->ephemeron_tombstone;
 553 }
 554
 555 MonoObject *
 556 ves_icall_System_GCHandle_GetTarget (guint32 handle)
 557 {
 558         return mono_gchandle_get_target (handle);
 559 }
 560
 561 /*
 562  * if type == -1, change the target of the handle, otherwise allocate a new handle.
 563  */
 564 guint32
 565 ves_icall_System_GCHandle_GetTargetHandle (MonoObject *obj, guint32 handle, gint32 type)
 566 {
 567         if (type == -1) {
 568                 mono_gchandle_set_target (handle, obj);
 569                 /* the handle doesn't change */
 570                 return handle;
 571         }
 572         switch (type) {
 573         case HANDLE_WEAK:
 574                 return mono_gchandle_new_weakref (obj, FALSE);
 575         case HANDLE_WEAK_TRACK:
 576                 return mono_gchandle_new_weakref (obj, TRUE);
 577         case HANDLE_NORMAL:
 578                 return mono_gchandle_new (obj, FALSE);
 579         case HANDLE_PINNED:
 580                 return mono_gchandle_new (obj, TRUE);
 581         default:
 582                 g_assert_not_reached ();
 583         }
 584         return 0;
 585 }
 586
 587 void
 588 ves_icall_System_GCHandle_FreeHandle (guint32 handle)
 589 {
 590         mono_gchandle_free (handle);
 591 }
 592
 593 gpointer
 594 ves_icall_System_GCHandle_GetAddrOfPinnedObject (guint32 handle)
 595 {
 596         MonoObject *obj;
 597
 598         if (MONO_GC_HANDLE_TYPE (handle) != HANDLE_PINNED)
 599                 return (gpointer)-2;
 600         obj = mono_gchandle_get_target (handle);
 601         if (obj) {
 602                 MonoClass *klass = mono_object_class (obj);
 603                 if (klass == mono_defaults.string_class) {
 604                         return mono_string_chars ((MonoString*)obj);
 605                 } else if (klass->rank) {
 606                         return mono_array_addr ((MonoArray*)obj, char, 0);
 607                 } else {
 608                         /* the C# code will check and throw the exception */
 609                         /* FIXME: missing !klass->blittable test, see bug #61134 */
 610                         if ((klass->flags & TYPE_ATTRIBUTE_LAYOUT_MASK) == TYPE_ATTRIBUTE_AUTO_LAYOUT)
 611                                 return (gpointer)-1;
 612                         return (char*)obj + sizeof (MonoObject);
 613                 }
 614         }
 615         return NULL;
 616 }
 617
 618 MonoBoolean
 619 mono_gc_GCHandle_CheckCurrentDomain (guint32 gchandle)
 620 {
 621         return mono_gchandle_is_in_domain (gchandle, mono_domain_get ());
 622 }
 623
 624 static MonoCoopSem finalizer_sem;
 625 static volatile gboolean finished=FALSE;
 626
 627 void
 628 mono_gc_finalize_notify (void)
 629 {
 630 #ifdef DEBUG
 631         g_message ( "%s: prodding finalizer", __func__);
 632 #endif
 633
 634         if (mono_gc_is_null ())
 635                 return;
 636
 637         mono_coop_sem_post (&finalizer_sem);
 638 }
 639
 640 /*
 641 This is the number of entries allowed in the hazard free queue before
 642 we explicitly cycle the finalizer thread to trigger pumping the queue.
 643
 644 It was picked empirically by running the corlib test suite in a stress
 645 scenario where all hazard entries are queued.
 646
 647 In this extreme scenario we double the number of times we cycle the finalizer
 648 thread compared to just GC calls.
 649
 650 Entries are usually in the order of 100's of bytes each, so we're limiting
 651 floating garbage to be in the order of a dozen kb.
 652 */
 653 static gboolean finalizer_thread_pulsed;
 654 #define HAZARD_QUEUE_OVERFLOW_SIZE 20
 655
 656 static void
 657 hazard_free_queue_is_too_big (size_t size)
 658 {
 659         if (size < HAZARD_QUEUE_OVERFLOW_SIZE)
 660                 return;
 661
 662         if (finalizer_thread_pulsed || InterlockedCompareExchange (&finalizer_thread_pulsed, TRUE, FALSE))
 663                 return;
 664
 665         mono_gc_finalize_notify ();
 666 }
 667
 668 static void
 669 hazard_free_queue_pump (void)
 670 {
 671         mono_thread_hazardous_try_free_all ();
 672         finalizer_thread_pulsed = FALSE;
 673 }
 674
 675 #ifdef HAVE_BOEHM_GC
 676
 677 static void
 678 collect_objects (gpointer key, gpointer value, gpointer user_data)
 679 {
 680         GPtrArray *arr = (GPtrArray*)user_data;
 681         g_ptr_array_add (arr, key);
 682 }
 683
 684 #endif
 685
 686 /*
 687  * finalize_domain_objects:
 688  *
 689  *  Run the finalizers of all finalizable objects in req->domain.
 690  */
 691 static void
 692 finalize_domain_objects (DomainFinalizationReq *req)
 693 {
 694         MonoDomain *domain = req->domain;
 695
 696         /* Process finalizers which are already in the queue */
 697         mono_gc_invoke_finalizers ();
 698
 699 #ifdef HAVE_BOEHM_GC
 700         while (g_hash_table_size (domain->finalizable_objects_hash) > 0) {
 701                 int i;
 702                 GPtrArray *objs;
 703                 /*
 704                  * Since the domain is unloading, nobody is allowed to put
 705                  * new entries into the hash table. But finalize_object might
 706                  * remove entries from the hash table, so we make a copy.
 707                  */
 708                 objs = g_ptr_array_new ();
 709                 g_hash_table_foreach (domain->finalizable_objects_hash, collect_objects, objs);
 710                 /* printf ("FINALIZING %d OBJECTS.\n", objs->len); */
 711
 712                 for (i = 0; i < objs->len; ++i) {
 713                         MonoObject *o = (MonoObject*)g_ptr_array_index (objs, i);
 714                         /* FIXME: Avoid finalizing threads, etc */
 715                         mono_gc_run_finalize (o, 0);
 716                 }
 717
 718                 g_ptr_array_free (objs, TRUE);
 719         }
 720 #elif defined(HAVE_SGEN_GC)
 721         mono_gc_finalize_domain (domain, &suspend_finalizers);
 722         mono_gc_invoke_finalizers ();
 723 #endif
 724
 725         /* cleanup the reference queue */
 726         reference_queue_clear_for_domain (domain);
 727
 728         /* printf ("DONE.\n"); */
 729         SetEvent (req->done_event);
 730
 731         /* The event is closed in mono_domain_finalize if we get here */
 732         g_free (req);
 733 }
 734
 735 static guint32
 736 finalizer_thread (gpointer unused)
 737 {
 738         MonoError error;
 739         mono_thread_set_name_internal (mono_thread_internal_current (), mono_string_new (mono_get_root_domain (), "Finalizer"), FALSE, &error);
 740         mono_error_assert_ok (&error);
 741
 742         gboolean wait = TRUE;
 743
 744         /* Register a hazard free queue pump callback */
 745         mono_hazard_pointer_install_free_queue_size_callback (hazard_free_queue_is_too_big);
 746
 747         while (!finished) {
 748                 /* Wait to be notified that there's at least one
 749                  * finaliser to run
 750                  */
 751
 752                 g_assert (mono_domain_get () == mono_get_root_domain ());
 753                 mono_gc_set_skip_thread (TRUE);
 754
 755                 if (wait) {
 756                         /* An alertable wait is required so this thread can be suspended on windows */
 757                         mono_coop_sem_wait (&finalizer_sem, MONO_SEM_FLAGS_ALERTABLE);
 758                 }
 759                 wait = TRUE;
 760
 761                 mono_gc_set_skip_thread (FALSE);
 762
 763                 mono_threads_perform_thread_dump ();
 764
 765                 mono_console_handle_async_ops ();
 766
 767                 mono_attach_maybe_start ();
 768
 769                 if (domains_to_finalize) {
 770                         mono_finalizer_lock ();
 771                         if (domains_to_finalize) {
 772                                 DomainFinalizationReq *req = (DomainFinalizationReq *)domains_to_finalize->data;
 773                                 domains_to_finalize = g_slist_remove (domains_to_finalize, req);
 774                                 mono_finalizer_unlock ();
 775
 776                                 finalize_domain_objects (req);
 777                         } else {
 778                                 mono_finalizer_unlock ();
 779                         }
 780                 }
 781
 782                 /* If finished == TRUE, mono_gc_cleanup has been called (from mono_runtime_cleanup),
 783                  * before the domain is unloaded.
 784                  */
 785                 mono_gc_invoke_finalizers ();
 786
 787                 mono_threads_join_threads ();
 788
 789                 reference_queue_proccess_all ();
 790
 791                 hazard_free_queue_pump ();
 792
 793                 /* Avoid posting the pending done event until there are pending finalizers */
 794                 if (mono_coop_sem_timedwait (&finalizer_sem, 0, MONO_SEM_FLAGS_NONE) == 0) {
 795                         /* Don't wait again at the start of the loop */
 796                         wait = FALSE;
 797                 } else {
 798                         SetEvent (pending_done_event);
 799                 }
 800         }
 801
 802         mono_finalizer_lock ();
 803         finalizer_thread_exited = TRUE;
 804         mono_coop_cond_signal (&exited_cond);
 805         mono_finalizer_unlock ();
 806
 807         return 0;
 808 }
 809
 810 #ifndef LAZY_GC_THREAD_CREATION
 811 static
 812 #endif
 813 void
 814 mono_gc_init_finalizer_thread (void)
 815 {
 816         MonoError error;
 817         gc_thread = mono_thread_create_internal (mono_domain_get (), finalizer_thread, NULL, FALSE, 0, &error);
 818         mono_error_assert_ok (&error);
 819 }
 820
 821 void
 822 mono_gc_init (void)
 823 {
 824         mono_coop_mutex_init_recursive (&finalizer_mutex);
 825         mono_coop_mutex_init_recursive (&reference_queue_mutex);
 826
 827         mono_counters_register ("Minor GC collections", MONO_COUNTER_GC | MONO_COUNTER_UINT, &gc_stats.minor_gc_count);
 828         mono_counters_register ("Major GC collections", MONO_COUNTER_GC | MONO_COUNTER_UINT, &gc_stats.major_gc_count);
 829         mono_counters_register ("Minor GC time", MONO_COUNTER_GC | MONO_COUNTER_ULONG | MONO_COUNTER_TIME, &gc_stats.minor_gc_time);
 830         mono_counters_register ("Major GC time", MONO_COUNTER_GC | MONO_COUNTER_ULONG | MONO_COUNTER_TIME, &gc_stats.major_gc_time);
 831         mono_counters_register ("Major GC time concurrent", MONO_COUNTER_GC | MONO_COUNTER_ULONG | MONO_COUNTER_TIME, &gc_stats.major_gc_time_concurrent);
 832
 833         mono_gc_base_init ();
 834
 835         if (mono_gc_is_disabled ()) {
 836                 gc_disabled = TRUE;
 837                 return;
 838         }
 839
 840         pending_done_event = CreateEvent (NULL, TRUE, FALSE, NULL);
 841         g_assert (pending_done_event);
 842         mono_coop_cond_init (&exited_cond);
 843         mono_coop_sem_init (&finalizer_sem, 0);
 844
 845 #ifndef LAZY_GC_THREAD_CREATION
 846         mono_gc_init_finalizer_thread ();
 847 #endif
 848 }
 849
 850 void
 851 mono_gc_cleanup (void)
 852 {
 853 #ifdef DEBUG
 854         g_message ("%s: cleaning up finalizer", __func__);
 855 #endif
 856
 857         if (mono_gc_is_null ())
 858                 return;
 859
 860         if (!gc_disabled) {
 861                 finished = TRUE;
 862                 if (mono_thread_internal_current () != gc_thread) {
 863                         gint64 start_ticks = mono_msec_ticks ();
 864                         gint64 end_ticks = start_ticks + 2000;
 865
 866                         mono_gc_finalize_notify ();
 867                         /* Finishing the finalizer thread, so wait a little bit... */
 868                         /* MS seems to wait for about 2 seconds */
 869                         while (!finalizer_thread_exited) {
 870                                 gint64 current_ticks = mono_msec_ticks ();
 871                                 guint32 timeout;
 872
 873                                 if (current_ticks >= end_ticks)
 874                                         break;
 875                                 else
 876                                         timeout = end_ticks - current_ticks;
 877                                 mono_finalizer_lock ();
 878                                 if (!finalizer_thread_exited)
 879                                         mono_coop_cond_timedwait (&exited_cond, &finalizer_mutex, timeout);
 880                                 mono_finalizer_unlock ();
 881                         }
 882
 883                         if (!finalizer_thread_exited) {
 884                                 int ret;
 885
 886                                 /* Set a flag which the finalizer thread can check */
 887                                 suspend_finalizers = TRUE;
 888
 889                                 /* Try to abort the thread, in the hope that it is running managed code */
 890                                 mono_thread_internal_abort (gc_thread);
 891
 892                                 /* Wait for it to stop */
 893                                 ret = guarded_wait (gc_thread->handle, 100, TRUE);
 894
 895                                 if (ret == WAIT_TIMEOUT) {
 896                                         /*
 897                                          * The finalizer thread refused to exit. Make it stop.
 898                                          */
 899                                         mono_thread_internal_stop (gc_thread);
 900                                         ret = guarded_wait (gc_thread->handle, 100, TRUE);
 901                                         g_assert (ret != WAIT_TIMEOUT);
 902                                         /* The thread can't set this flag */
 903                                         finalizer_thread_exited = TRUE;
 904                                 }
 905                         }
 906
 907                         int ret;
 908
 909                         /* Wait for the thread to actually exit */
 910                         ret = guarded_wait (gc_thread->handle, INFINITE, TRUE);
 911                         g_assert (ret == WAIT_OBJECT_0);
 912
 913                         mono_thread_join (GUINT_TO_POINTER (gc_thread->tid));
 914                         g_assert (finalizer_thread_exited);
 915                 }
 916                 gc_thread = NULL;
 917                 mono_gc_base_cleanup ();
 918         }
 919
 920         mono_reference_queue_cleanup ();
 921
 922         mono_coop_mutex_destroy (&finalizer_mutex);
 923         mono_coop_mutex_destroy (&reference_queue_mutex);
 924 }
 925
 926 gboolean
 927 mono_gc_is_finalizer_internal_thread (MonoInternalThread *thread)
 928 {
 929         return thread == gc_thread;
 930 }
 931
 932 /**
 933  * mono_gc_is_finalizer_thread:
 934  * @thread: the thread to test.
 935  *
 936  * In Mono objects are finalized asynchronously on a separate thread.
 937  * This routine tests whether the @thread argument represents the
 938  * finalization thread.
 939  *
 940  * Returns: TRUE if @thread is the finalization thread.
 941  */
 942 gboolean
 943 mono_gc_is_finalizer_thread (MonoThread *thread)
 944 {
 945         return mono_gc_is_finalizer_internal_thread (thread->internal_thread);
 946 }
 947
 948 #if defined(__MACH__)
 949 static pthread_t mach_exception_thread;
 950
 951 void
 952 mono_gc_register_mach_exception_thread (pthread_t thread)
 953 {
 954         mach_exception_thread = thread;
 955 }
 956
 957 pthread_t
 958 mono_gc_get_mach_exception_thread (void)
 959 {
 960         return mach_exception_thread;
 961 }
 962 #endif
 963
 964 static MonoReferenceQueue *ref_queues;
 965
 966 static void
 967 ref_list_remove_element (RefQueueEntry **prev, RefQueueEntry *element)
 968 {
 969         do {
 970                 /* Guard if head is changed concurrently. */
 971                 while (*prev != element)
 972                         prev = &(*prev)->next;
 973         } while (prev && InterlockedCompareExchangePointer ((volatile gpointer *)prev, element->next, element) != element);
 974 }
 975
 976 static void
 977 ref_list_push (RefQueueEntry **head, RefQueueEntry *value)
 978 {
 979         RefQueueEntry *current;
 980         do {
 981                 current = *head;
 982                 value->next = current;
 983                 STORE_STORE_FENCE; /*Must make sure the previous store is visible before the CAS. */
 984         } while (InterlockedCompareExchangePointer ((volatile gpointer *)head, value, current) != current);
 985 }
 986
 987 static void
 988 reference_queue_proccess (MonoReferenceQueue *queue)
 989 {
 990         RefQueueEntry **iter = &queue->queue;
 991         RefQueueEntry *entry;
 992         while ((entry = *iter)) {
 993                 if (queue->should_be_deleted || !mono_gchandle_get_target (entry->gchandle)) {
 994                         mono_gchandle_free ((guint32)entry->gchandle);
 995                         ref_list_remove_element (iter, entry);
 996                         queue->callback (entry->user_data);
 997                         g_free (entry);
 998                 } else {
 999                         iter = &entry->next;
1000                 }
1001         }
1002 }
1003
1004 static void
1005 reference_queue_proccess_all (void)
1006 {
1007         MonoReferenceQueue **iter;
1008         MonoReferenceQueue *queue = ref_queues;
1009         for (; queue; queue = queue->next)
1010                 reference_queue_proccess (queue);
1011
1012 restart:
1013         mono_coop_mutex_lock (&reference_queue_mutex);
1014         for (iter = &ref_queues; *iter;) {
1015                 queue = *iter;
1016                 if (!queue->should_be_deleted) {
1017                         iter = &queue->next;
1018                         continue;
1019                 }
1020                 if (queue->queue) {
1021                         mono_coop_mutex_unlock (&reference_queue_mutex);
1022                         reference_queue_proccess (queue);
1023                         goto restart;
1024                 }
1025                 *iter = queue->next;
1026                 g_free (queue);
1027         }
1028         mono_coop_mutex_unlock (&reference_queue_mutex);
1029 }
1030
1031 static void
1032 mono_reference_queue_cleanup (void)
1033 {
1034         MonoReferenceQueue *queue = ref_queues;
1035         for (; queue; queue = queue->next)
1036                 queue->should_be_deleted = TRUE;
1037         reference_queue_proccess_all ();
1038 }
1039
1040 static void
1041 reference_queue_clear_for_domain (MonoDomain *domain)
1042 {
1043         MonoReferenceQueue *queue = ref_queues;
1044         for (; queue; queue = queue->next) {
1045                 RefQueueEntry **iter = &queue->queue;
1046                 RefQueueEntry *entry;
1047                 while ((entry = *iter)) {
1048                         if (entry->domain == domain) {
1049                                 mono_gchandle_free ((guint32)entry->gchandle);
1050                                 ref_list_remove_element (iter, entry);
1051                                 queue->callback (entry->user_data);
1052                                 g_free (entry);
1053                         } else {
1054                                 iter = &entry->next;
1055                         }
1056                 }
1057         }
1058 }
1059 /**
1060  * mono_gc_reference_queue_new:
1061  * @callback callback used when processing collected entries.
1062  *
1063  * Create a new reference queue used to process collected objects.
1064  * A reference queue let you add a pair of (managed object, user data)
1065  * using the mono_gc_reference_queue_add method.
1066  *
1067  * Once the managed object is collected @callback will be called
1068  * in the finalizer thread with 'user data' as argument.
1069  *
1070  * The callback is called from the finalizer thread without any locks held.
1071  * When a AppDomain is unloaded, all callbacks for objects belonging to it
1072  * will be invoked.
1073  *
1074  * @returns the new queue.
1075  */
1076 MonoReferenceQueue*
1077 mono_gc_reference_queue_new (mono_reference_queue_callback callback)
1078 {
1079         MonoReferenceQueue *res = g_new0 (MonoReferenceQueue, 1);
1080         res->callback = callback;
1081
1082         mono_coop_mutex_lock (&reference_queue_mutex);
1083         res->next = ref_queues;
1084         ref_queues = res;
1085         mono_coop_mutex_unlock (&reference_queue_mutex);
1086
1087         return res;
1088 }
1089
1090 /**
1091  * mono_gc_reference_queue_add:
1092  * @queue the queue to add the reference to.
1093  * @obj the object to be watched for collection
1094  * @user_data parameter to be passed to the queue callback
1095  *
1096  * Queue an object to be watched for collection, when the @obj is
1097  * collected, the callback that was registered for the @queue will
1098  * be invoked with @user_data as argument.
1099  *
1100  * @returns false if the queue is scheduled to be freed.
1101  */
1102 gboolean
1103 mono_gc_reference_queue_add (MonoReferenceQueue *queue, MonoObject *obj, void *user_data)
1104 {
1105         RefQueueEntry *entry;
1106         if (queue->should_be_deleted)
1107                 return FALSE;
1108
1109         g_assert (obj != NULL);
1110
1111         entry = g_new0 (RefQueueEntry, 1);
1112         entry->user_data = user_data;
1113         entry->domain = mono_object_domain (obj);
1114
1115         entry->gchandle = mono_gchandle_new_weakref (obj, TRUE);
1116         mono_object_register_finalizer (obj);
1117
1118         ref_list_push (&queue->queue, entry);
1119         return TRUE;
1120 }
1121
1122 /**
1123  * mono_gc_reference_queue_free:
1124  * @queue the queue that should be freed.
1125  *
1126  * This operation signals that @queue should be freed. This operation is deferred
1127  * as it happens on the finalizer thread.
1128  *
1129  * After this call, no further objects can be queued. It's the responsibility of the
1130  * caller to make sure that no further attempt to access queue will be made.
1131  */
1132 void
1133 mono_gc_reference_queue_free (MonoReferenceQueue *queue)
1134 {
1135         queue->should_be_deleted = TRUE;
1136 }