static void
mono_backtrace (int size)
{
void *array[BACKTRACE_DEPTH];
char **names;
int i, symbols;
static gboolean inited;
if (!inited) {
mono_os_mutex_init_recursive (&mempool_tracing_lock);
inited = TRUE;
}
mono_os_mutex_lock (&mempool_tracing_lock);
g_print ("Allocating %d bytes\n", size);
MONO_ENTER_GC_SAFE;
symbols = backtrace (array, BACKTRACE_DEPTH);
names = backtrace_symbols (array, symbols);
MONO_EXIT_GC_SAFE;
for (i = 1; i < symbols; ++i) {
g_print ("\t%s\n", names [i]);
}
g_free (names);
mono_os_mutex_unlock (&mempool_tracing_lock);
}
static void*
codechunk_valloc (void *preferred, guint32 size)
{
void *ptr;
GSList *freelist;
if (!valloc_freelists) {
mono_os_mutex_init_recursive (&valloc_mutex);
valloc_freelists = g_hash_table_new (NULL, NULL);
}
/*
* Keep a small freelist of memory blocks to decrease pressure on the kernel memory subsystem to avoid #3321.
*/
mono_os_mutex_lock (&valloc_mutex);
freelist = (GSList *) g_hash_table_lookup (valloc_freelists, GUINT_TO_POINTER (size));
if (freelist) {
ptr = freelist->data;
memset (ptr, 0, size);
freelist = g_slist_delete_link (freelist, freelist);
g_hash_table_insert (valloc_freelists, GUINT_TO_POINTER (size), freelist);
} else {
ptr = mono_valloc (preferred, size, MONO_PROT_RWX | ARCH_MAP_FLAGS, MONO_MEM_ACCOUNT_CODE);
if (!ptr && preferred)
ptr = mono_valloc (NULL, size, MONO_PROT_RWX | ARCH_MAP_FLAGS, MONO_MEM_ACCOUNT_CODE);
}
mono_os_mutex_unlock (&valloc_mutex);
return ptr;
}
/**
* mono_profiler_install:
* @prof: a MonoProfiler structure pointer, or a pointer to a derived structure.
* @callback: the function to invoke at shutdown
*
* Use mono_profiler_install to activate profiling in the Mono runtime.
* Typically developers of new profilers will create a new structure whose
* first field is a MonoProfiler and put any extra information that they need
* to access from the various profiling callbacks there.
*
*/
void
mono_profiler_install (MonoProfiler *prof, MonoProfileFunc callback)
{
ProfilerDesc *desc = g_new0 (ProfilerDesc, 1);
if (!prof_list)
mono_os_mutex_init_recursive (&profiler_coverage_mutex);
desc->profiler = prof;
desc->shutdown_callback = callback;
desc->next = prof_list;
prof_list = desc;
}
void
mono_tasklets_init (void)
{
mono_os_mutex_init_recursive (&tasklets_mutex);
mono_add_internal_call ("Mono.Tasklets.Continuation::alloc", continuation_alloc);
mono_add_internal_call ("Mono.Tasklets.Continuation::free", continuation_free);
mono_add_internal_call ("Mono.Tasklets.Continuation::mark", continuation_mark_frame);
mono_add_internal_call ("Mono.Tasklets.Continuation::store", continuation_store);
mono_add_internal_call ("Mono.Tasklets.Continuation::restore", continuation_restore);
}
void
mono_thread_smr_init (void)
{
int i;
mono_os_mutex_init_recursive(&small_id_mutex);
mono_counters_register ("Hazardous pointers", MONO_COUNTER_JIT | MONO_COUNTER_INT, &hazardous_pointer_count);
for (i = 0; i < HAZARD_TABLE_OVERFLOW; ++i) {
int small_id = mono_thread_small_id_alloc ();
g_assert (small_id == i);
}
}
void
sgen_section_gray_queue_init (SgenSectionGrayQueue *queue, gboolean locked, GrayQueueEnqueueCheckFunc enqueue_check_func)
{
g_assert (sgen_section_gray_queue_is_empty (queue));
queue->locked = locked;
if (locked) {
mono_os_mutex_init_recursive (&queue->lock);
}
#ifdef SGEN_CHECK_GRAY_OBJECT_ENQUEUE
queue->enqueue_check_func = enqueue_check_func;
#endif
}
void
mono_locks_tracer_init (void)
{
Dl_info info;
int res;
char *name;
mono_os_mutex_init_recursive (&tracer_lock);
if (!g_getenv ("MONO_ENABLE_LOCK_TRACER"))
return;
name = g_strdup_printf ("locks.%d", getpid ());
trace_file = fopen (name, "w+");
g_free (name);
#ifdef TARGET_OSX
res = dladdr ((void*)&mono_locks_tracer_init, &info);
/* The 0x1000 offset was found by empirically trying it. */
if (res)
base_address = (size_t)info.dli_fbase - 0x1000;
#endif
}
/*
* Initialize debugging support.
*
* This method must be called after loading corlib,
* but before opening the application's main assembly because we need to set some
* callbacks here.
*/
void
mono_debug_init (MonoDebugFormat format)
{
g_assert (!mono_debug_initialized);
if (format == MONO_DEBUG_FORMAT_DEBUGGER)
g_error ("The mdb debugger is no longer supported.");
mono_debug_initialized = TRUE;
mono_debug_format = format;
mono_os_mutex_init_recursive (&debugger_lock_mutex);
mono_debugger_lock ();
mono_debug_handles = g_hash_table_new_full
(NULL, NULL, NULL, (GDestroyNotify) free_debug_handle);
data_table_hash = g_hash_table_new_full (
NULL, NULL, NULL, (GDestroyNotify) free_data_table);
mono_install_assembly_load_hook (mono_debug_add_assembly, NULL);
mono_debugger_unlock ();
}