2 * metadata/gc.c: GC icalls.
4 * Author: Paolo Molaro <lupus@ximian.com>
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)
16 #include <mono/metadata/gc-internal.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/threadpool.h>
27 #include <mono/metadata/threadpool-internals.h>
28 #include <mono/metadata/threads-types.h>
29 #include <mono/metadata/sgen-conf.h>
30 #include <mono/utils/mono-logger-internal.h>
31 #include <mono/metadata/gc-internal.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-semaphore.h>
36 #include <mono/utils/mono-memory-model.h>
37 #include <mono/utils/mono-counters.h>
38 #include <mono/utils/dtrace.h>
39 #include <mono/utils/mono-threads.h>
40 #include <mono/utils/atomic.h>
46 typedef struct DomainFinalizationReq {
49 } DomainFinalizationReq;
51 #ifdef PLATFORM_WINCE /* FIXME: add accessors to gc.dll API */
52 extern void (*__imp_GC_finalizer_notifier)(void);
53 #define GC_finalizer_notifier __imp_GC_finalizer_notifier
54 extern int __imp_GC_finalize_on_demand;
55 #define GC_finalize_on_demand __imp_GC_finalize_on_demand
58 static gboolean gc_disabled = FALSE;
60 static gboolean finalizing_root_domain = FALSE;
62 #define mono_finalizer_lock() EnterCriticalSection (&finalizer_mutex)
63 #define mono_finalizer_unlock() LeaveCriticalSection (&finalizer_mutex)
64 static CRITICAL_SECTION finalizer_mutex;
65 static CRITICAL_SECTION reference_queue_mutex;
67 static GSList *domains_to_finalize= NULL;
68 static MonoMList *threads_to_finalize = NULL;
70 static MonoInternalThread *gc_thread;
72 static void object_register_finalizer (MonoObject *obj, void (*callback)(void *, void*));
74 static void mono_gchandle_set_target (guint32 gchandle, MonoObject *obj);
76 static void reference_queue_proccess_all (void);
77 static void mono_reference_queue_cleanup (void);
78 static void reference_queue_clear_for_domain (MonoDomain *domain);
80 static HANDLE pending_done_event;
81 static HANDLE shutdown_event;
87 add_thread_to_finalize (MonoInternalThread *thread)
89 mono_finalizer_lock ();
90 if (!threads_to_finalize)
91 MONO_GC_REGISTER_ROOT_SINGLE (threads_to_finalize);
92 threads_to_finalize = mono_mlist_append (threads_to_finalize, (MonoObject*)thread);
93 mono_finalizer_unlock ();
96 static gboolean suspend_finalizers = FALSE;
98 * actually, we might want to queue the finalize requests in a separate thread,
99 * but we need to be careful about the execution domain of the thread...
102 mono_gc_run_finalize (void *obj, void *data)
104 MonoObject *exc = NULL;
109 MonoMethod* finalizer = NULL;
110 MonoDomain *caller_domain = mono_domain_get ();
112 RuntimeInvokeFunction runtime_invoke;
114 o = (MonoObject*)((char*)obj + GPOINTER_TO_UINT (data));
116 if (suspend_finalizers)
119 domain = o->vtable->domain;
122 mono_domain_finalizers_lock (domain);
124 o2 = g_hash_table_lookup (domain->finalizable_objects_hash, o);
126 mono_domain_finalizers_unlock (domain);
129 /* Already finalized somehow */
133 /* make sure the finalizer is not called again if the object is resurrected */
134 object_register_finalizer (obj, NULL);
136 if (o->vtable->klass == mono_defaults.internal_thread_class) {
137 MonoInternalThread *t = (MonoInternalThread*)o;
139 if (mono_gc_is_finalizer_internal_thread (t))
140 /* Avoid finalizing ourselves */
143 if (t->threadpool_thread && finalizing_root_domain) {
144 /* Don't finalize threadpool threads when
145 shutting down - they're finalized when the
146 threadpool shuts down. */
147 add_thread_to_finalize (t);
152 if (o->vtable->klass->image == mono_defaults.corlib && !strcmp (o->vtable->klass->name, "DynamicMethod") && finalizing_root_domain) {
154 * These can't be finalized during unloading/shutdown, since that would
155 * free the native code which can still be referenced by other
157 * FIXME: This is not perfect, objects dying at the same time as
158 * dynamic methods can still reference them even when !shutdown.
163 if (mono_runtime_get_no_exec ())
166 /* speedup later... and use a timeout */
167 /* g_print ("Finalize run on %p %s.%s\n", o, mono_object_class (o)->name_space, mono_object_class (o)->name); */
169 /* Use _internal here, since this thread can enter a doomed appdomain */
170 mono_domain_set_internal (mono_object_domain (o));
172 /* delegates that have a native function pointer allocated are
173 * registered for finalization, but they don't have a Finalize
174 * method, because in most cases it's not needed and it's just a waste.
176 if (o->vtable->klass->delegate) {
177 MonoDelegate* del = (MonoDelegate*)o;
178 if (del->delegate_trampoline)
179 mono_delegate_free_ftnptr ((MonoDelegate*)o);
180 mono_domain_set_internal (caller_domain);
184 finalizer = mono_class_get_finalizer (o->vtable->klass);
187 /* If object has a CCW but has no finalizer, it was only
188 * registered for finalization in order to free the CCW.
189 * Else it needs the regular finalizer run.
190 * FIXME: what to do about ressurection and suppression
191 * of finalizer on object with CCW.
193 if (mono_marshal_free_ccw (o) && !finalizer) {
194 mono_domain_set_internal (caller_domain);
200 * To avoid the locking plus the other overhead of mono_runtime_invoke (),
201 * create and precompile a wrapper which calls the finalize method using
204 if (!domain->finalize_runtime_invoke) {
205 MonoMethod *invoke = mono_marshal_get_runtime_invoke (mono_class_get_method_from_name_flags (mono_defaults.object_class, "Finalize", 0, 0), TRUE);
207 domain->finalize_runtime_invoke = mono_compile_method (invoke);
210 runtime_invoke = domain->finalize_runtime_invoke;
212 mono_runtime_class_init (o->vtable);
214 if (G_UNLIKELY (MONO_GC_FINALIZE_INVOKE_ENABLED ())) {
215 MONO_GC_FINALIZE_INVOKE ((unsigned long)o, mono_object_get_size (o),
216 o->vtable->klass->name_space, o->vtable->klass->name);
219 runtime_invoke (o, NULL, &exc, NULL);
222 mono_internal_thread_unhandled_exception (exc);
224 mono_domain_set_internal (caller_domain);
228 mono_gc_finalize_threadpool_threads (void)
230 while (threads_to_finalize) {
231 MonoInternalThread *thread = (MonoInternalThread*) mono_mlist_get_data (threads_to_finalize);
233 /* Force finalization of the thread. */
234 thread->threadpool_thread = FALSE;
235 mono_object_register_finalizer ((MonoObject*)thread);
237 mono_gc_run_finalize (thread, NULL);
239 threads_to_finalize = mono_mlist_next (threads_to_finalize);
244 mono_gc_out_of_memory (size_t size)
247 * we could allocate at program startup some memory that we could release
248 * back to the system at this point if we're really low on memory (ie, size is
249 * lower than the memory we set apart)
251 mono_raise_exception (mono_domain_get ()->out_of_memory_ex);
257 * Some of our objects may point to a different address than the address returned by GC_malloc()
258 * (because of the GetHashCode hack), but we need to pass the real address to register_finalizer.
259 * This also means that in the callback we need to adjust the pointer to get back the real
261 * We also need to be consistent in the use of the GC_debug* variants of malloc and register_finalizer,
262 * since that, too, can cause the underlying pointer to be offset.
265 object_register_finalizer (MonoObject *obj, void (*callback)(void *, void*))
270 mono_raise_exception (mono_get_exception_argument_null ("obj"));
272 domain = obj->vtable->domain;
275 if (mono_domain_is_unloading (domain) && (callback != NULL))
277 * Can't register finalizers in a dying appdomain, since they
278 * could be invoked after the appdomain has been unloaded.
282 mono_domain_finalizers_lock (domain);
285 g_hash_table_insert (domain->finalizable_objects_hash, obj, obj);
287 g_hash_table_remove (domain->finalizable_objects_hash, obj);
289 mono_domain_finalizers_unlock (domain);
291 mono_gc_register_for_finalization (obj, callback);
292 #elif defined(HAVE_SGEN_GC)
294 * If we register finalizers for domains that are unloading we might
295 * end up running them while or after the domain is being cleared, so
296 * the objects will not be valid anymore.
298 if (!mono_domain_is_unloading (domain))
299 mono_gc_register_for_finalization (obj, callback);
304 * mono_object_register_finalizer:
305 * @obj: object to register
307 * Records that object @obj has a finalizer, this will call the
308 * Finalize method when the garbage collector disposes the object.
312 mono_object_register_finalizer (MonoObject *obj)
314 /* g_print ("Registered finalizer on %p %s.%s\n", obj, mono_object_class (obj)->name_space, mono_object_class (obj)->name); */
315 object_register_finalizer (obj, mono_gc_run_finalize);
319 * mono_domain_finalize:
320 * @domain: the domain to finalize
321 * @timeout: msects to wait for the finalization to complete, -1 to wait indefinitely
323 * Request finalization of all finalizable objects inside @domain. Wait
324 * @timeout msecs for the finalization to complete.
326 * Returns: TRUE if succeeded, FALSE if there was a timeout
330 mono_domain_finalize (MonoDomain *domain, guint32 timeout)
332 DomainFinalizationReq *req;
335 MonoInternalThread *thread = mono_thread_internal_current ();
337 #if defined(__native_client__)
341 if (mono_thread_internal_current () == gc_thread)
342 /* We are called from inside a finalizer, not much we can do here */
346 * No need to create another thread 'cause the finalizer thread
347 * is still working and will take care of running the finalizers
354 mono_gc_collect (mono_gc_max_generation ());
356 done_event = CreateEvent (NULL, TRUE, FALSE, NULL);
357 if (done_event == NULL) {
361 req = g_new0 (DomainFinalizationReq, 1);
362 req->domain = domain;
363 req->done_event = done_event;
365 if (domain == mono_get_root_domain ())
366 finalizing_root_domain = TRUE;
368 mono_finalizer_lock ();
370 domains_to_finalize = g_slist_append (domains_to_finalize, req);
372 mono_finalizer_unlock ();
374 /* Tell the finalizer thread to finalize this appdomain */
375 mono_gc_finalize_notify ();
381 res = WaitForSingleObjectEx (done_event, timeout, TRUE);
382 /* printf ("WAIT RES: %d.\n", res); */
384 if (res == WAIT_IO_COMPLETION) {
385 if ((thread->state & (ThreadState_StopRequested | ThreadState_SuspendRequested)) != 0)
387 } else if (res == WAIT_TIMEOUT) {
388 /* We leak the handle here */
395 CloseHandle (done_event);
397 if (domain == mono_get_root_domain ()) {
398 mono_thread_pool_cleanup ();
399 mono_gc_finalize_threadpool_threads ();
404 /* We don't support domain finalization without a GC */
410 ves_icall_System_GC_InternalCollect (int generation)
412 mono_gc_collect (generation);
416 ves_icall_System_GC_GetTotalMemory (MonoBoolean forceCollection)
421 mono_gc_collect (mono_gc_max_generation ());
422 return mono_gc_get_used_size ();
426 ves_icall_System_GC_KeepAlive (MonoObject *obj)
436 ves_icall_System_GC_ReRegisterForFinalize (MonoObject *obj)
439 mono_raise_exception (mono_get_exception_argument_null ("obj"));
441 object_register_finalizer (obj, mono_gc_run_finalize);
445 ves_icall_System_GC_SuppressFinalize (MonoObject *obj)
448 mono_raise_exception (mono_get_exception_argument_null ("obj"));
450 /* delegates have no finalizers, but we register them to deal with the
451 * unmanaged->managed trampoline. We don't let the user suppress it
452 * otherwise we'd leak it.
454 if (obj->vtable->klass->delegate)
457 /* FIXME: Need to handle case where obj has COM Callable Wrapper
458 * generated for it that needs cleaned up, but user wants to suppress
459 * their derived object finalizer. */
461 object_register_finalizer (obj, NULL);
465 ves_icall_System_GC_WaitForPendingFinalizers (void)
468 if (!mono_gc_pending_finalizers ())
471 if (mono_thread_internal_current () == gc_thread)
472 /* Avoid deadlocks */
476 If the finalizer thread is not live, lets pretend no finalizers are pending since the current thread might
477 be the one responsible for starting it up.
479 if (gc_thread == NULL)
482 ResetEvent (pending_done_event);
483 mono_gc_finalize_notify ();
484 /* g_print ("Waiting for pending finalizers....\n"); */
485 WaitForSingleObjectEx (pending_done_event, INFINITE, TRUE);
486 /* g_print ("Done pending....\n"); */
491 ves_icall_System_GC_register_ephemeron_array (MonoObject *array)
494 if (!mono_gc_ephemeron_array_add (array))
495 mono_raise_exception (mono_object_domain (array)->out_of_memory_ex);
500 ves_icall_System_GC_get_ephemeron_tombstone (void)
502 return mono_domain_get ()->ephemeron_tombstone;
505 #define mono_allocator_lock() EnterCriticalSection (&allocator_section)
506 #define mono_allocator_unlock() LeaveCriticalSection (&allocator_section)
507 static CRITICAL_SECTION allocator_section;
508 static CRITICAL_SECTION handle_section;
517 static HandleType mono_gchandle_get_type (guint32 gchandle);
520 ves_icall_System_GCHandle_GetTarget (guint32 handle)
522 return mono_gchandle_get_target (handle);
526 * if type == -1, change the target of the handle, otherwise allocate a new handle.
529 ves_icall_System_GCHandle_GetTargetHandle (MonoObject *obj, guint32 handle, gint32 type)
532 mono_gchandle_set_target (handle, obj);
533 /* the handle doesn't change */
538 return mono_gchandle_new_weakref (obj, FALSE);
539 case HANDLE_WEAK_TRACK:
540 return mono_gchandle_new_weakref (obj, TRUE);
542 return mono_gchandle_new (obj, FALSE);
544 return mono_gchandle_new (obj, TRUE);
546 g_assert_not_reached ();
552 ves_icall_System_GCHandle_FreeHandle (guint32 handle)
554 mono_gchandle_free (handle);
558 ves_icall_System_GCHandle_GetAddrOfPinnedObject (guint32 handle)
562 if (mono_gchandle_get_type (handle) != HANDLE_PINNED)
564 obj = mono_gchandle_get_target (handle);
566 MonoClass *klass = mono_object_class (obj);
567 if (klass == mono_defaults.string_class) {
568 return mono_string_chars ((MonoString*)obj);
569 } else if (klass->rank) {
570 return mono_array_addr ((MonoArray*)obj, char, 0);
572 /* the C# code will check and throw the exception */
573 /* FIXME: missing !klass->blittable test, see bug #61134 */
574 if ((klass->flags & TYPE_ATTRIBUTE_LAYOUT_MASK) == TYPE_ATTRIBUTE_AUTO_LAYOUT)
576 return (char*)obj + sizeof (MonoObject);
583 ves_icall_Mono_Runtime_SetGCAllowSynchronousMajor (MonoBoolean flag)
585 return mono_gc_set_allow_synchronous_major (flag);
593 guint slot_hint : 24; /* starting slot for search */
594 /* 2^16 appdomains should be enough for everyone (though I know I'll regret this in 20 years) */
595 /* we alloc this only for weak refs, since we can get the domain directly in the other cases */
599 /* weak and weak-track arrays will be allocated in malloc memory
601 static HandleData gc_handles [] = {
602 {NULL, NULL, 0, HANDLE_WEAK, 0},
603 {NULL, NULL, 0, HANDLE_WEAK_TRACK, 0},
604 {NULL, NULL, 0, HANDLE_NORMAL, 0},
605 {NULL, NULL, 0, HANDLE_PINNED, 0}
608 #define lock_handles(handles) EnterCriticalSection (&handle_section)
609 #define unlock_handles(handles) LeaveCriticalSection (&handle_section)
612 find_first_unset (guint32 bitmap)
615 for (i = 0; i < 32; ++i) {
616 if (!(bitmap & (1 << i)))
623 make_root_descr_all_refs (int numbits, gboolean pinned)
629 return mono_gc_make_root_descr_all_refs (numbits);
633 alloc_handle (HandleData *handles, MonoObject *obj, gboolean track)
637 lock_handles (handles);
638 if (!handles->size) {
640 if (handles->type > HANDLE_WEAK_TRACK) {
641 handles->entries = mono_gc_alloc_fixed (sizeof (gpointer) * handles->size, make_root_descr_all_refs (handles->size, handles->type == HANDLE_PINNED));
643 handles->entries = g_malloc0 (sizeof (gpointer) * handles->size);
644 handles->domain_ids = g_malloc0 (sizeof (guint16) * handles->size);
646 handles->bitmap = g_malloc0 (handles->size / 8);
649 for (slot = handles->slot_hint; slot < handles->size / 32; ++slot) {
650 if (handles->bitmap [slot] != 0xffffffff) {
651 i = find_first_unset (handles->bitmap [slot]);
652 handles->slot_hint = slot;
656 if (i == -1 && handles->slot_hint != 0) {
657 for (slot = 0; slot < handles->slot_hint; ++slot) {
658 if (handles->bitmap [slot] != 0xffffffff) {
659 i = find_first_unset (handles->bitmap [slot]);
660 handles->slot_hint = slot;
667 guint32 new_size = handles->size * 2; /* always double: we memset to 0 based on this below */
669 /* resize and copy the bitmap */
670 new_bitmap = g_malloc0 (new_size / 8);
671 memcpy (new_bitmap, handles->bitmap, handles->size / 8);
672 g_free (handles->bitmap);
673 handles->bitmap = new_bitmap;
675 /* resize and copy the entries */
676 if (handles->type > HANDLE_WEAK_TRACK) {
679 entries = mono_gc_alloc_fixed (sizeof (gpointer) * new_size, make_root_descr_all_refs (new_size, handles->type == HANDLE_PINNED));
680 mono_gc_memmove_aligned (entries, handles->entries, sizeof (gpointer) * handles->size);
682 mono_gc_free_fixed (handles->entries);
683 handles->entries = entries;
687 domain_ids = g_malloc0 (sizeof (guint16) * new_size);
688 entries = g_malloc0 (sizeof (gpointer) * new_size);
689 memcpy (domain_ids, handles->domain_ids, sizeof (guint16) * handles->size);
690 for (i = 0; i < handles->size; ++i) {
691 MonoObject *obj = mono_gc_weak_link_get (&(handles->entries [i]));
693 mono_gc_weak_link_add (&(entries [i]), obj, track);
694 mono_gc_weak_link_remove (&(handles->entries [i]), track);
696 g_assert (!handles->entries [i]);
699 g_free (handles->entries);
700 g_free (handles->domain_ids);
701 handles->entries = entries;
702 handles->domain_ids = domain_ids;
705 /* set i and slot to the next free position */
707 slot = (handles->size + 1) / 32;
708 handles->slot_hint = handles->size + 1;
709 handles->size = new_size;
711 handles->bitmap [slot] |= 1 << i;
712 slot = slot * 32 + i;
713 handles->entries [slot] = NULL;
714 if (handles->type <= HANDLE_WEAK_TRACK) {
715 /*FIXME, what to use when obj == null?*/
716 handles->domain_ids [slot] = (obj ? mono_object_get_domain (obj) : mono_domain_get ())->domain_id;
718 mono_gc_weak_link_add (&(handles->entries [slot]), obj, track);
720 handles->entries [slot] = obj;
723 #ifndef DISABLE_PERFCOUNTERS
724 mono_perfcounters->gc_num_handles++;
726 unlock_handles (handles);
727 /*g_print ("allocated entry %d of type %d to object %p (in slot: %p)\n", slot, handles->type, obj, handles->entries [slot]);*/
728 res = (slot << 3) | (handles->type + 1);
729 mono_profiler_gc_handle (MONO_PROFILER_GC_HANDLE_CREATED, handles->type, res, obj);
735 * @obj: managed object to get a handle for
736 * @pinned: whether the object should be pinned
738 * This returns a handle that wraps the object, this is used to keep a
739 * reference to a managed object from the unmanaged world and preventing the
740 * object from being disposed.
742 * If @pinned is false the address of the object can not be obtained, if it is
743 * true the address of the object can be obtained. This will also pin the
744 * object so it will not be possible by a moving garbage collector to move the
747 * Returns: a handle that can be used to access the object from
751 mono_gchandle_new (MonoObject *obj, gboolean pinned)
753 return alloc_handle (&gc_handles [pinned? HANDLE_PINNED: HANDLE_NORMAL], obj, FALSE);
757 * mono_gchandle_new_weakref:
758 * @obj: managed object to get a handle for
759 * @pinned: whether the object should be pinned
761 * This returns a weak handle that wraps the object, this is used to
762 * keep a reference to a managed object from the unmanaged world.
763 * Unlike the mono_gchandle_new the object can be reclaimed by the
764 * garbage collector. In this case the value of the GCHandle will be
767 * If @pinned is false the address of the object can not be obtained, if it is
768 * true the address of the object can be obtained. This will also pin the
769 * object so it will not be possible by a moving garbage collector to move the
772 * Returns: a handle that can be used to access the object from
776 mono_gchandle_new_weakref (MonoObject *obj, gboolean track_resurrection)
778 guint32 handle = alloc_handle (&gc_handles [track_resurrection? HANDLE_WEAK_TRACK: HANDLE_WEAK], obj, track_resurrection);
784 mono_gchandle_get_type (guint32 gchandle)
786 guint type = (gchandle & 7) - 1;
792 * mono_gchandle_get_target:
793 * @gchandle: a GCHandle's handle.
795 * The handle was previously created by calling mono_gchandle_new or
796 * mono_gchandle_new_weakref.
798 * Returns a pointer to the MonoObject represented by the handle or
799 * NULL for a collected object if using a weakref handle.
802 mono_gchandle_get_target (guint32 gchandle)
804 guint slot = gchandle >> 3;
805 guint type = (gchandle & 7) - 1;
806 HandleData *handles = &gc_handles [type];
807 MonoObject *obj = NULL;
810 lock_handles (handles);
811 if (slot < handles->size && (handles->bitmap [slot / 32] & (1 << (slot % 32)))) {
812 if (handles->type <= HANDLE_WEAK_TRACK) {
813 obj = mono_gc_weak_link_get (&handles->entries [slot]);
815 obj = handles->entries [slot];
818 /* print a warning? */
820 unlock_handles (handles);
821 /*g_print ("get target of entry %d of type %d: %p\n", slot, handles->type, obj);*/
826 mono_gchandle_set_target (guint32 gchandle, MonoObject *obj)
828 guint slot = gchandle >> 3;
829 guint type = (gchandle & 7) - 1;
830 HandleData *handles = &gc_handles [type];
831 MonoObject *old_obj = NULL;
835 lock_handles (handles);
836 if (slot < handles->size && (handles->bitmap [slot / 32] & (1 << (slot % 32)))) {
837 if (handles->type <= HANDLE_WEAK_TRACK) {
838 old_obj = handles->entries [slot];
839 if (handles->entries [slot])
840 mono_gc_weak_link_remove (&handles->entries [slot], handles->type == HANDLE_WEAK_TRACK);
842 mono_gc_weak_link_add (&handles->entries [slot], obj, handles->type == HANDLE_WEAK_TRACK);
843 /*FIXME, what to use when obj == null?*/
844 handles->domain_ids [slot] = (obj ? mono_object_get_domain (obj) : mono_domain_get ())->domain_id;
846 handles->entries [slot] = obj;
849 /* print a warning? */
851 /*g_print ("changed entry %d of type %d to object %p (in slot: %p)\n", slot, handles->type, obj, handles->entries [slot]);*/
852 unlock_handles (handles);
856 * mono_gchandle_is_in_domain:
857 * @gchandle: a GCHandle's handle.
858 * @domain: An application domain.
860 * Returns: true if the object wrapped by the @gchandle belongs to the specific @domain.
863 mono_gchandle_is_in_domain (guint32 gchandle, MonoDomain *domain)
865 guint slot = gchandle >> 3;
866 guint type = (gchandle & 7) - 1;
867 HandleData *handles = &gc_handles [type];
868 gboolean result = FALSE;
871 lock_handles (handles);
872 if (slot < handles->size && (handles->bitmap [slot / 32] & (1 << (slot % 32)))) {
873 if (handles->type <= HANDLE_WEAK_TRACK) {
874 result = domain->domain_id == handles->domain_ids [slot];
877 obj = handles->entries [slot];
881 result = domain == mono_object_domain (obj);
884 /* print a warning? */
886 unlock_handles (handles);
891 * mono_gchandle_free:
892 * @gchandle: a GCHandle's handle.
894 * Frees the @gchandle handle. If there are no outstanding
895 * references, the garbage collector can reclaim the memory of the
899 mono_gchandle_free (guint32 gchandle)
901 guint slot = gchandle >> 3;
902 guint type = (gchandle & 7) - 1;
903 HandleData *handles = &gc_handles [type];
907 lock_handles (handles);
908 if (slot < handles->size && (handles->bitmap [slot / 32] & (1 << (slot % 32)))) {
909 if (handles->type <= HANDLE_WEAK_TRACK) {
910 if (handles->entries [slot])
911 mono_gc_weak_link_remove (&handles->entries [slot], handles->type == HANDLE_WEAK_TRACK);
913 handles->entries [slot] = NULL;
915 handles->bitmap [slot / 32] &= ~(1 << (slot % 32));
917 /* print a warning? */
919 #ifndef DISABLE_PERFCOUNTERS
920 mono_perfcounters->gc_num_handles--;
922 /*g_print ("freed entry %d of type %d\n", slot, handles->type);*/
923 unlock_handles (handles);
924 mono_profiler_gc_handle (MONO_PROFILER_GC_HANDLE_DESTROYED, handles->type, gchandle, NULL);
928 * mono_gchandle_free_domain:
929 * @domain: domain that is unloading
931 * Function used internally to cleanup any GC handle for objects belonging
932 * to the specified domain during appdomain unload.
935 mono_gchandle_free_domain (MonoDomain *domain)
939 for (type = 0; type < 3; ++type) {
941 HandleData *handles = &gc_handles [type];
942 lock_handles (handles);
943 for (slot = 0; slot < handles->size; ++slot) {
944 if (!(handles->bitmap [slot / 32] & (1 << (slot % 32))))
946 if (type <= HANDLE_WEAK_TRACK) {
947 if (domain->domain_id == handles->domain_ids [slot]) {
948 handles->bitmap [slot / 32] &= ~(1 << (slot % 32));
949 if (handles->entries [slot])
950 mono_gc_weak_link_remove (&handles->entries [slot], handles->type == HANDLE_WEAK_TRACK);
953 if (handles->entries [slot] && mono_object_domain (handles->entries [slot]) == domain) {
954 handles->bitmap [slot / 32] &= ~(1 << (slot % 32));
955 handles->entries [slot] = NULL;
959 unlock_handles (handles);
965 GCHandle_CheckCurrentDomain (guint32 gchandle)
967 return mono_gchandle_is_in_domain (gchandle, mono_domain_get ());
972 #ifdef MONO_HAS_SEMAPHORES
973 static MonoSemType finalizer_sem;
975 static HANDLE finalizer_event;
976 static volatile gboolean finished=FALSE;
979 mono_gc_finalize_notify (void)
982 g_message ( "%s: prodding finalizer", __func__);
985 #ifdef MONO_HAS_SEMAPHORES
986 MONO_SEM_POST (&finalizer_sem);
988 SetEvent (finalizer_event);
995 collect_objects (gpointer key, gpointer value, gpointer user_data)
997 GPtrArray *arr = (GPtrArray*)user_data;
998 g_ptr_array_add (arr, key);
1004 * finalize_domain_objects:
1006 * Run the finalizers of all finalizable objects in req->domain.
1009 finalize_domain_objects (DomainFinalizationReq *req)
1011 MonoDomain *domain = req->domain;
1014 #define NUM_FOBJECTS 64
1015 MonoObject *to_finalize [NUM_FOBJECTS];
1019 /* Process finalizers which are already in the queue */
1020 mono_gc_invoke_finalizers ();
1022 #ifdef HAVE_BOEHM_GC
1023 while (g_hash_table_size (domain->finalizable_objects_hash) > 0) {
1027 * Since the domain is unloading, nobody is allowed to put
1028 * new entries into the hash table. But finalize_object might
1029 * remove entries from the hash table, so we make a copy.
1031 objs = g_ptr_array_new ();
1032 g_hash_table_foreach (domain->finalizable_objects_hash, collect_objects, objs);
1033 /* printf ("FINALIZING %d OBJECTS.\n", objs->len); */
1035 for (i = 0; i < objs->len; ++i) {
1036 MonoObject *o = (MonoObject*)g_ptr_array_index (objs, i);
1037 /* FIXME: Avoid finalizing threads, etc */
1038 mono_gc_run_finalize (o, 0);
1041 g_ptr_array_free (objs, TRUE);
1043 #elif defined(HAVE_SGEN_GC)
1044 while ((count = mono_gc_finalizers_for_domain (domain, to_finalize, NUM_FOBJECTS))) {
1046 for (i = 0; i < count; ++i) {
1047 mono_gc_run_finalize (to_finalize [i], 0);
1052 /* cleanup the reference queue */
1053 reference_queue_clear_for_domain (domain);
1055 /* printf ("DONE.\n"); */
1056 SetEvent (req->done_event);
1058 /* The event is closed in mono_domain_finalize if we get here */
1063 finalizer_thread (gpointer unused)
1066 /* Wait to be notified that there's at least one
1070 g_assert (mono_domain_get () == mono_get_root_domain ());
1072 /* An alertable wait is required so this thread can be suspended on windows */
1073 #ifdef MONO_HAS_SEMAPHORES
1074 MONO_SEM_WAIT_ALERTABLE (&finalizer_sem, TRUE);
1076 WaitForSingleObjectEx (finalizer_event, INFINITE, TRUE);
1079 mono_threads_perform_thread_dump ();
1081 mono_console_handle_async_ops ();
1083 #ifndef DISABLE_ATTACH
1084 mono_attach_maybe_start ();
1087 if (domains_to_finalize) {
1088 mono_finalizer_lock ();
1089 if (domains_to_finalize) {
1090 DomainFinalizationReq *req = domains_to_finalize->data;
1091 domains_to_finalize = g_slist_remove (domains_to_finalize, req);
1092 mono_finalizer_unlock ();
1094 finalize_domain_objects (req);
1096 mono_finalizer_unlock ();
1100 /* If finished == TRUE, mono_gc_cleanup has been called (from mono_runtime_cleanup),
1101 * before the domain is unloaded.
1103 mono_gc_invoke_finalizers ();
1105 mono_threads_join_threads ();
1107 reference_queue_proccess_all ();
1109 SetEvent (pending_done_event);
1112 SetEvent (shutdown_event);
1116 #ifndef LAZY_GC_THREAD_CREATION
1120 mono_gc_init_finalizer_thread (void)
1122 gc_thread = mono_thread_create_internal (mono_domain_get (), finalizer_thread, NULL, FALSE, 0);
1123 ves_icall_System_Threading_Thread_SetName_internal (gc_thread, mono_string_new (mono_domain_get (), "Finalizer"));
1129 InitializeCriticalSection (&handle_section);
1130 InitializeCriticalSection (&allocator_section);
1132 InitializeCriticalSection (&finalizer_mutex);
1133 InitializeCriticalSection (&reference_queue_mutex);
1135 MONO_GC_REGISTER_ROOT_FIXED (gc_handles [HANDLE_NORMAL].entries);
1136 MONO_GC_REGISTER_ROOT_FIXED (gc_handles [HANDLE_PINNED].entries);
1138 mono_counters_register ("Created object count", MONO_COUNTER_GC | MONO_COUNTER_ULONG, &mono_stats.new_object_count);
1139 mono_counters_register ("Minor GC collections", MONO_COUNTER_GC | MONO_COUNTER_INT, &gc_stats.minor_gc_count);
1140 mono_counters_register ("Major GC collections", MONO_COUNTER_GC | MONO_COUNTER_INT, &gc_stats.major_gc_count);
1141 mono_counters_register ("Minor GC time", MONO_COUNTER_GC | MONO_COUNTER_LONG | MONO_COUNTER_TIME, &gc_stats.minor_gc_time_usecs);
1142 mono_counters_register ("Major GC time", MONO_COUNTER_GC | MONO_COUNTER_LONG | MONO_COUNTER_TIME, &gc_stats.major_gc_time_usecs);
1143 #ifdef HEAVY_STATISTICS
1144 mono_counters_register ("Gray Queue alloc section", MONO_COUNTER_GC | MONO_COUNTER_ULONG, &gc_stats.gray_queue_section_alloc);
1145 mono_counters_register ("Gray Queue free section", MONO_COUNTER_GC | MONO_COUNTER_ULONG, &gc_stats.gray_queue_section_free);
1146 mono_counters_register ("Gray Queue enqueue fast path", MONO_COUNTER_GC | MONO_COUNTER_ULONG, &gc_stats.gray_queue_enqueue_fast_path);
1147 mono_counters_register ("Gray Queue dequeue fast path", MONO_COUNTER_GC | MONO_COUNTER_ULONG, &gc_stats.gray_queue_dequeue_fast_path);
1148 mono_counters_register ("Gray Queue enqueue slow path", MONO_COUNTER_GC | MONO_COUNTER_ULONG, &gc_stats.gray_queue_enqueue_slow_path);
1149 mono_counters_register ("Gray Queue dequeue slow path", MONO_COUNTER_GC | MONO_COUNTER_ULONG, &gc_stats.gray_queue_dequeue_slow_path);
1152 mono_gc_base_init ();
1154 if (mono_gc_is_disabled ()) {
1159 finalizer_event = CreateEvent (NULL, FALSE, FALSE, NULL);
1160 pending_done_event = CreateEvent (NULL, TRUE, FALSE, NULL);
1161 shutdown_event = CreateEvent (NULL, TRUE, FALSE, NULL);
1162 if (finalizer_event == NULL || pending_done_event == NULL || shutdown_event == NULL) {
1163 g_assert_not_reached ();
1165 #ifdef MONO_HAS_SEMAPHORES
1166 MONO_SEM_INIT (&finalizer_sem, 0);
1169 #ifndef LAZY_GC_THREAD_CREATION
1170 mono_gc_init_finalizer_thread ();
1175 mono_gc_cleanup (void)
1178 g_message ("%s: cleaning up finalizer", __func__);
1182 ResetEvent (shutdown_event);
1184 if (mono_thread_internal_current () != gc_thread) {
1185 gboolean timed_out = FALSE;
1187 mono_gc_finalize_notify ();
1188 /* Finishing the finalizer thread, so wait a little bit... */
1189 /* MS seems to wait for about 2 seconds */
1190 if (WaitForSingleObjectEx (shutdown_event, 2000, FALSE) == WAIT_TIMEOUT) {
1193 /* Set a flag which the finalizer thread can check */
1194 suspend_finalizers = TRUE;
1196 /* Try to abort the thread, in the hope that it is running managed code */
1197 mono_thread_internal_stop (gc_thread);
1199 /* Wait for it to stop */
1200 ret = WaitForSingleObjectEx (gc_thread->handle, 100, TRUE);
1202 if (ret == WAIT_TIMEOUT) {
1204 * The finalizer thread refused to die. There is not much we
1205 * can do here, since the runtime is shutting down so the
1206 * state the finalizer thread depends on will vanish.
1208 g_warning ("Shutting down finalizer thread timed out.");
1216 /* Wait for the thread to actually exit */
1217 ret = WaitForSingleObjectEx (gc_thread->handle, INFINITE, TRUE);
1218 g_assert (ret == WAIT_OBJECT_0);
1220 mono_thread_join ((gpointer)gc_thread->tid);
1224 #ifdef HAVE_BOEHM_GC
1225 GC_finalizer_notifier = NULL;
1229 mono_reference_queue_cleanup ();
1231 DeleteCriticalSection (&handle_section);
1232 DeleteCriticalSection (&allocator_section);
1233 DeleteCriticalSection (&finalizer_mutex);
1234 DeleteCriticalSection (&reference_queue_mutex);
1239 /* Null GC dummy functions */
1241 mono_gc_finalize_notify (void)
1245 void mono_gc_init (void)
1247 InitializeCriticalSection (&handle_section);
1250 void mono_gc_cleanup (void)
1257 mono_gc_is_finalizer_internal_thread (MonoInternalThread *thread)
1259 return thread == gc_thread;
1263 * mono_gc_is_finalizer_thread:
1264 * @thread: the thread to test.
1266 * In Mono objects are finalized asynchronously on a separate thread.
1267 * This routine tests whether the @thread argument represents the
1268 * finalization thread.
1270 * Returns true if @thread is the finalization thread.
1273 mono_gc_is_finalizer_thread (MonoThread *thread)
1275 return mono_gc_is_finalizer_internal_thread (thread->internal_thread);
1278 #if defined(__MACH__)
1279 static pthread_t mach_exception_thread;
1282 mono_gc_register_mach_exception_thread (pthread_t thread)
1284 mach_exception_thread = thread;
1288 mono_gc_get_mach_exception_thread (void)
1290 return mach_exception_thread;
1295 * mono_gc_parse_environment_string_extract_number:
1297 * @str: points to the first digit of the number
1298 * @out: pointer to the variable that will receive the value
1300 * Tries to extract a number from the passed string, taking in to account m, k
1303 * Returns true if passing was successful
1306 mono_gc_parse_environment_string_extract_number (const char *str, size_t *out)
1309 int len = strlen (str), shift = 0;
1311 gboolean is_suffix = FALSE;
1317 suffix = str [len - 1];
1332 if (!isdigit (suffix))
1338 val = strtol (str, &endptr, 10);
1340 if ((errno == ERANGE && (val == LONG_MAX || val == LONG_MIN))
1341 || (errno != 0 && val == 0) || (endptr == str))
1347 if (val < 0) /* negative numbers cannot be suffixed */
1349 if (*(endptr + 1)) /* Invalid string. */
1352 unshifted = (size_t)val;
1354 if (val < 0) /* overflow */
1356 if (((size_t)val >> shift) != unshifted) /* value too large */
1364 #ifndef HAVE_SGEN_GC
1366 mono_gc_alloc_mature (MonoVTable *vtable)
1368 return mono_object_new_specific (vtable);
1373 static MonoReferenceQueue *ref_queues;
1376 ref_list_remove_element (RefQueueEntry **prev, RefQueueEntry *element)
1379 /* Guard if head is changed concurrently. */
1380 while (*prev != element)
1381 prev = &(*prev)->next;
1382 } while (prev && InterlockedCompareExchangePointer ((void*)prev, element->next, element) != element);
1386 ref_list_push (RefQueueEntry **head, RefQueueEntry *value)
1388 RefQueueEntry *current;
1391 value->next = current;
1392 STORE_STORE_FENCE; /*Must make sure the previous store is visible before the CAS. */
1393 } while (InterlockedCompareExchangePointer ((void*)head, value, current) != current);
1397 reference_queue_proccess (MonoReferenceQueue *queue)
1399 RefQueueEntry **iter = &queue->queue;
1400 RefQueueEntry *entry;
1401 while ((entry = *iter)) {
1403 if (queue->should_be_deleted || !mono_gc_weak_link_get (&entry->dis_link)) {
1404 mono_gc_weak_link_remove (&entry->dis_link, TRUE);
1406 if (queue->should_be_deleted || !mono_gchandle_get_target (entry->gchandle)) {
1407 mono_gchandle_free ((guint32)entry->gchandle);
1409 ref_list_remove_element (iter, entry);
1410 queue->callback (entry->user_data);
1413 iter = &entry->next;
1419 reference_queue_proccess_all (void)
1421 MonoReferenceQueue **iter;
1422 MonoReferenceQueue *queue = ref_queues;
1423 for (; queue; queue = queue->next)
1424 reference_queue_proccess (queue);
1427 EnterCriticalSection (&reference_queue_mutex);
1428 for (iter = &ref_queues; *iter;) {
1430 if (!queue->should_be_deleted) {
1431 iter = &queue->next;
1435 LeaveCriticalSection (&reference_queue_mutex);
1436 reference_queue_proccess (queue);
1439 *iter = queue->next;
1442 LeaveCriticalSection (&reference_queue_mutex);
1446 mono_reference_queue_cleanup (void)
1448 MonoReferenceQueue *queue = ref_queues;
1449 for (; queue; queue = queue->next)
1450 queue->should_be_deleted = TRUE;
1451 reference_queue_proccess_all ();
1455 reference_queue_clear_for_domain (MonoDomain *domain)
1457 MonoReferenceQueue *queue = ref_queues;
1458 for (; queue; queue = queue->next) {
1459 RefQueueEntry **iter = &queue->queue;
1460 RefQueueEntry *entry;
1461 while ((entry = *iter)) {
1462 if (entry->domain == domain) {
1464 mono_gc_weak_link_remove (&entry->dis_link, TRUE);
1466 mono_gchandle_free ((guint32)entry->gchandle);
1468 ref_list_remove_element (iter, entry);
1469 queue->callback (entry->user_data);
1472 iter = &entry->next;
1478 * mono_gc_reference_queue_new:
1479 * @callback callback used when processing collected entries.
1481 * Create a new reference queue used to process collected objects.
1482 * A reference queue let you add a pair of (managed object, user data)
1483 * using the mono_gc_reference_queue_add method.
1485 * Once the managed object is collected @callback will be called
1486 * in the finalizer thread with 'user data' as argument.
1488 * The callback is called from the finalizer thread without any locks held.
1489 * When a AppDomain is unloaded, all callbacks for objects belonging to it
1492 * @returns the new queue.
1495 mono_gc_reference_queue_new (mono_reference_queue_callback callback)
1497 MonoReferenceQueue *res = g_new0 (MonoReferenceQueue, 1);
1498 res->callback = callback;
1500 EnterCriticalSection (&reference_queue_mutex);
1501 res->next = ref_queues;
1503 LeaveCriticalSection (&reference_queue_mutex);
1509 * mono_gc_reference_queue_add:
1510 * @queue the queue to add the reference to.
1511 * @obj the object to be watched for collection
1512 * @user_data parameter to be passed to the queue callback
1514 * Queue an object to be watched for collection, when the @obj is
1515 * collected, the callback that was registered for the @queue will
1516 * be invoked with @user_data as argument.
1518 * @returns false if the queue is scheduled to be freed.
1521 mono_gc_reference_queue_add (MonoReferenceQueue *queue, MonoObject *obj, void *user_data)
1523 RefQueueEntry *entry;
1524 if (queue->should_be_deleted)
1527 entry = g_new0 (RefQueueEntry, 1);
1528 entry->user_data = user_data;
1529 entry->domain = mono_object_domain (obj);
1532 mono_gc_weak_link_add (&entry->dis_link, obj, TRUE);
1534 entry->gchandle = mono_gchandle_new_weakref (obj, TRUE);
1535 mono_object_register_finalizer (obj);
1538 ref_list_push (&queue->queue, entry);
1543 * mono_gc_reference_queue_free:
1544 * @queue the queue that should be freed.
1546 * This operation signals that @queue should be freed. This operation is deferred
1547 * as it happens on the finalizer thread.
1549 * After this call, no further objects can be queued. It's the responsibility of the
1550 * caller to make sure that no further attempt to access queue will be made.
1553 mono_gc_reference_queue_free (MonoReferenceQueue *queue)
1555 queue->should_be_deleted = TRUE;