#include <mono/utils/mono-stdlib.h>
#include <mono/utils/mono-io-portability.h>
#include <mono/utils/mono-error-internals.h>
+#include <mono/utils/atomic.h>
+#include <mono/utils/mono-memory-model.h>
+#include <mono/utils/mono-threads.h>
#ifdef HOST_WIN32
#include <direct.h>
#endif
* Changes which are already detected at runtime, like the addition
* of icalls, do not require an increment.
*/
-#define MONO_CORLIB_VERSION 108
+#define MONO_CORLIB_VERSION 111
typedef struct
{
static gunichar2 process_guid [36];
static gboolean process_guid_set = FALSE;
-static gboolean shutting_down = FALSE;
-
static gboolean no_exec = FALSE;
static MonoAssembly *
void
mono_runtime_cleanup (MonoDomain *domain)
{
- shutting_down = TRUE;
-
mono_attach_cleanup ();
/* This ends up calling any pending pending (for at most 2 seconds) */
quit_function (mono_get_root_domain (), NULL);
}
-/**
- * mono_runtime_set_shutting_down:
- *
- * Invoked by System.Environment.Exit to flag that the runtime
- * is shutting down.
- */
-void
-mono_runtime_set_shutting_down (void)
-{
- shutting_down = TRUE;
-}
-
-/**
- * mono_runtime_is_shutting_down:
- *
- * Returns whether the runtime has been flagged for shutdown.
- *
- * This is consumed by the P:System.Environment.HasShutdownStarted
- * property.
- *
- */
-gboolean
-mono_runtime_is_shutting_down (void)
-{
- return shutting_down;
-}
-
/**
* mono_domain_create_appdomain:
* @friendly_name: The friendly name of the appdomain to create
shadow_location = get_shadow_assembly_location_base (data, &error);
if (!mono_error_ok (&error))
mono_error_raise_exception (&error);
- mono_debugger_event_create_appdomain (data, shadow_location);
g_free (shadow_location);
#endif
MonoAppDomain *
ves_icall_System_AppDomain_createDomain (MonoString *friendly_name, MonoAppDomainSetup *setup)
{
+#ifdef DISABLE_APPDOMAINS
+ mono_raise_exception (mono_get_exception_not_supported ("AppDomain creation is not supported on this runtime."));
+ return NULL;
+#else
char *fname = mono_string_to_utf8 (friendly_name);
MonoAppDomain *ad = mono_domain_create_appdomain_internal (fname, setup);
g_free (fname);
return ad;
+#endif
}
MonoArray *
if (!g_hash_table_lookup (ht, ass)) {
mono_assembly_addref (ass);
g_hash_table_insert (ht, ass, ass);
- domain->domain_assemblies = g_slist_prepend (domain->domain_assemblies, ass);
+ domain->domain_assemblies = g_slist_append (domain->domain_assemblies, ass);
mono_trace (G_LOG_LEVEL_INFO, MONO_TRACE_ASSEMBLY, "Assembly %s[%p] added to domain %s, ref_count=%d", ass->aname.name, ass, domain->friendly_name, ass->ref_count);
}
private_file_needs_copying (const char *src, struct stat *sbuf_src, char *dest)
{
struct stat sbuf_dest;
+ gchar *stat_src;
gchar *real_src = mono_portability_find_file (src, TRUE);
if (!real_src)
- real_src = (gchar*)src;
-
- if (stat (real_src, sbuf_src) == -1) {
+ stat_src = (gchar*)src;
+ else
+ stat_src = real_src;
+
+ if (stat (stat_src, sbuf_src) == -1) {
time_t tnow = time (NULL);
+
+ if (real_src)
+ g_free (real_src);
+
memset (sbuf_src, 0, sizeof (*sbuf_src));
sbuf_src->st_mtime = tnow;
sbuf_src->st_atime = tnow;
return TRUE;
}
+ if (real_src)
+ g_free (real_src);
+
if (stat (dest, &sbuf_dest) == -1)
return TRUE;
/*
This function raises exceptions so it can cause as sorts of nasty stuff if called
while holding a lock.
+Returns old file name if shadow copy is disabled, new shadow copy file name if successful
+or NULL if source file not found.
FIXME bubble up the error instead of raising it here
*/
char *
gchar *sibling_source, *sibling_target;
gint sibling_source_len, sibling_target_len;
guint16 *orig, *dest;
+ guint32 attrs;
char *shadow;
gboolean copy_result;
MonoException *exc;
orig = g_utf8_to_utf16 (filename, strlen (filename), NULL, NULL, NULL);
dest = g_utf8_to_utf16 (shadow, strlen (shadow), NULL, NULL, NULL);
DeleteFile (dest);
+
+ /* Fix for bug #17066 - make sure we can read the file. if not then don't error but rather
+ * let the assembly fail to load. This ensures you can do Type.GetType("NS.T, NonExistantAssembly)
+ * and not have it runtime error" */
+ attrs = GetFileAttributes (orig);
+ if (attrs == INVALID_FILE_ATTRIBUTES) {
+ g_free (shadow);
+ return (char *)filename;
+ }
+
copy_result = CopyFile (orig, dest, FALSE);
/* Fix for bug #556884 - make sure the files have the correct mode so that they can be
if (copy_result == FALSE) {
g_free (shadow);
+
+ /* Fix for bug #17251 - if file not found try finding assembly by other means (it is not fatal error) */
+ if (GetLastError() == ERROR_FILE_NOT_FOUND || GetLastError() == ERROR_PATH_NOT_FOUND)
+ return NULL; /* file not found, shadow copy failed */
+
exc = mono_get_exception_execution_engine ("Failed to create shadow copy (CopyFile).");
mono_raise_exception (exc);
}
if (!parsed) {
/* This is a parse error... */
- return NULL;
+ if (!refOnly)
+ refass = mono_try_assembly_resolve (domain, assRef, refOnly);
+ return refass;
}
ass = mono_assembly_load_full_nosearch (&aname, NULL, &status, refOnly);
*/
if (g_getenv ("MONO_NO_UNLOAD"))
return;
+#ifdef __native_client__
+ return;
+#endif
mono_domain_unload (domain);
}
}
typedef struct unload_data {
+ gboolean done;
MonoDomain *domain;
char *failure_reason;
+ gint32 refcount;
} unload_data;
static void
-deregister_reflection_info_roots_nspace_table (gpointer key, gpointer value, gpointer image)
-{
- guint32 index = GPOINTER_TO_UINT (value);
- MonoClass *class = mono_class_get (image, MONO_TOKEN_TYPE_DEF | index);
-
- g_assert (class);
-
- mono_class_free_ref_info (class);
-}
-
-static void
-deregister_reflection_info_roots_name_space (gpointer key, gpointer value, gpointer user_data)
-{
- g_hash_table_foreach (value, deregister_reflection_info_roots_nspace_table, user_data);
+unload_data_unref (unload_data *data)
+{
+ gint32 count;
+ do {
+ mono_atomic_load_acquire (count, gint32, &data->refcount);
+ g_assert (count >= 1 && count <= 2);
+ if (count == 1) {
+ g_free (data);
+ return;
+ }
+ } while (InterlockedCompareExchange (&data->refcount, count, count - 1) != count);
}
static void
list = list->next;
}
- g_slist_free (image->reflection_info_unregister_classes);
image->reflection_info_unregister_classes = NULL;
}
{
GSList *list;
- mono_loader_lock ();
mono_domain_assemblies_lock (domain);
for (list = domain->domain_assemblies; list; list = list->next) {
MonoAssembly *assembly = list->data;
MonoImage *image = assembly->image;
int i;
- /*No need to take the image lock here since dynamic images are appdomain bound and at this point the mutator is gone.*/
- if (image->dynamic && image->name_cache)
- g_hash_table_foreach (image->name_cache, deregister_reflection_info_roots_name_space, image);
- deregister_reflection_info_roots_from_list (image);
+
+ /*
+ * No need to take the image lock here since dynamic images are appdomain bound and
+ * at this point the mutator is gone. Taking the image lock here would mean
+ * promoting it from a simple lock to a complex lock, which we better avoid if
+ * possible.
+ */
+ if (image->dynamic)
+ deregister_reflection_info_roots_from_list (image);
+
for (i = 0; i < image->module_count; ++i) {
MonoImage *module = image->modules [i];
- if (module) {
- if (module->dynamic && module->name_cache) {
- g_hash_table_foreach (module->name_cache,
- deregister_reflection_info_roots_name_space, module);
- }
+ if (module && module->dynamic)
deregister_reflection_info_roots_from_list (module);
- }
}
}
mono_domain_assemblies_unlock (domain);
- mono_loader_unlock ();
}
static guint32 WINAPI
int i;
/* Have to attach to the runtime so shutdown can wait for this thread */
- thread = mono_thread_attach (mono_get_root_domain ());
+ /* Force it to be attached to avoid racing during shutdown. */
+ thread = mono_thread_attach_full (mono_get_root_domain (), TRUE);
/*
* FIXME: Abort our parent thread last, so we can return a failure
*/
if (!mono_threads_abort_appdomain_threads (domain, -1)) {
data->failure_reason = g_strdup_printf ("Aborting of threads in domain %s timed out.", domain->friendly_name);
- return 1;
+ goto failure;
}
if (!mono_thread_pool_remove_domain_jobs (domain, -1)) {
data->failure_reason = g_strdup_printf ("Cleanup of threadpool jobs of domain %s timed out.", domain->friendly_name);
- return 1;
+ goto failure;
}
/* Finalize all finalizable objects in the doomed appdomain */
if (!mono_domain_finalize (domain, -1)) {
data->failure_reason = g_strdup_printf ("Finalization of domain %s timed out.", domain->friendly_name);
- return 1;
+ goto failure;
}
/* Clear references to our vtables in class->runtime_info.
mono_gc_collect (mono_gc_max_generation ());
+ mono_atomic_store_release (&data->done, TRUE);
+ unload_data_unref (data);
mono_thread_detach (thread);
-
return 0;
+
+failure:
+ mono_atomic_store_release (&data->done, TRUE);
+ unload_data_unref (data);
+ mono_thread_detach (thread);
+ return 1;
}
/*
mono_domain_try_unload (MonoDomain *domain, MonoObject **exc)
{
HANDLE thread_handle;
- gsize tid;
- guint32 res;
MonoAppDomainState prev_state;
MonoMethod *method;
- unload_data thread_data;
+ unload_data *thread_data;
+ MonoNativeThreadId tid;
MonoDomain *caller_domain = mono_domain_get ();
/* printf ("UNLOAD STARTING FOR %s (%p) IN THREAD 0x%x.\n", domain->friendly_name, domain, GetCurrentThreadId ()); */
}
}
- mono_debugger_event_unload_appdomain (domain);
-
mono_domain_set (domain, FALSE);
/* Notify OnDomainUnload listeners */
method = mono_class_get_method_from_name (domain->domain->mbr.obj.vtable->klass, "DoDomainUnload", -1);
}
mono_domain_set (caller_domain, FALSE);
- thread_data.domain = domain;
- thread_data.failure_reason = NULL;
+ thread_data = g_new0 (unload_data, 1);
+ thread_data->domain = domain;
+ thread_data->failure_reason = NULL;
+ thread_data->done = FALSE;
+ thread_data->refcount = 2; /*Must be 2: unload thread + initiator */
/*The managed callback finished successfully, now we start tearing down the appdomain*/
domain->state = MONO_APPDOMAIN_UNLOADING;
* First we create a separate thread for unloading, since
* we might have to abort some threads, including the current one.
*/
- /*
- * If we create a non-suspended thread, the runtime will hang.
- * See:
- * http://bugzilla.ximian.com/show_bug.cgi?id=27663
- */
-#if 0
- thread_handle = mono_create_thread (NULL, 0, unload_thread_main, &thread_data, 0, &tid);
-#else
- thread_handle = mono_create_thread (NULL, 0, (LPTHREAD_START_ROUTINE)unload_thread_main, &thread_data, CREATE_SUSPENDED, &tid);
- if (thread_handle == NULL) {
+ thread_handle = mono_threads_create_thread ((LPTHREAD_START_ROUTINE)unload_thread_main, thread_data, 0, CREATE_SUSPENDED, &tid);
+ if (thread_handle == NULL)
return;
- }
- ResumeThread (thread_handle);
-#endif
+ mono_thread_info_resume (tid);
/* Wait for the thread */
- while ((res = WaitForSingleObjectEx (thread_handle, INFINITE, TRUE) == WAIT_IO_COMPLETION)) {
+ while (!thread_data->done && WaitForSingleObjectEx (thread_handle, INFINITE, TRUE) == WAIT_IO_COMPLETION) {
if (mono_thread_internal_has_appdomain_ref (mono_thread_internal_current (), domain) && (mono_thread_interruption_requested ())) {
/* The unload thread tries to abort us */
/* The icall wrapper will execute the abort */
CloseHandle (thread_handle);
+ unload_data_unref (thread_data);
return;
}
}
CloseHandle (thread_handle);
- if (thread_data.failure_reason) {
+ if (thread_data->failure_reason) {
/* Roll back the state change */
domain->state = MONO_APPDOMAIN_CREATED;
- g_warning ("%s", thread_data.failure_reason);
+ g_warning ("%s", thread_data->failure_reason);
- *exc = (MonoObject *) mono_get_exception_cannot_unload_appdomain (thread_data.failure_reason);
+ *exc = (MonoObject *) mono_get_exception_cannot_unload_appdomain (thread_data->failure_reason);
- g_free (thread_data.failure_reason);
- thread_data.failure_reason = NULL;
+ g_free (thread_data->failure_reason);
+ thread_data->failure_reason = NULL;
}
+
+ unload_data_unref (thread_data);
}
projects / mono.git / blobdiff