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