/*
* appdomain.c: AppDomain functions
*
- * Author:
+ * Authors:
* Dietmar Maurer (dietmar@ximian.com)
+ * Patrik Torstensson
+ * Gonzalo Paniagua Javier (gonzalo@ximian.com)
*
- * (C) 2001 Ximian, Inc.
+ * (c) 2001-2003 Ximian, Inc. (http://www.ximian.com)
*/
#include <config.h>
#include <mono/metadata/threads.h>
#include <mono/metadata/socket-io.h>
#include <mono/metadata/tabledefs.h>
-#include <mono/metadata/gc.h>
+#include <mono/metadata/gc-internal.h>
+#include <mono/metadata/marshal.h>
+#include <mono/utils/mono-uri.h>
+
+#define MONO_CORLIB_VERSION 20
-HANDLE mono_delegate_semaphore = NULL;
CRITICAL_SECTION mono_delegate_section;
-static MonoObject *
-mono_domain_transfer_object (MonoDomain *src, MonoDomain *dst, MonoObject *obj);
+static gunichar2 process_guid [36];
+static gboolean process_guid_set = FALSE;
+
+static gboolean shutting_down = FALSE;
+
+static MonoAssembly *
+mono_domain_assembly_preload (MonoAssemblyName *aname,
+ gchar **assemblies_path,
+ gpointer user_data);
+
static void
mono_domain_fire_assembly_load (MonoAssembly *assembly, gpointer user_data);
+static MonoMethod *
+look_for_method_by_name (MonoClass *klass, const gchar *name);
+
+static void
+mono_domain_unload (MonoDomain *domain);
+
/*
* mono_runtime_init:
* @domain: domain returned by mono_init ()
*/
void
mono_runtime_init (MonoDomain *domain, MonoThreadStartCB start_cb,
- MonoThreadStartCB attach_cb)
+ MonoThreadAttachCB attach_cb)
{
MonoAppDomainSetup *setup;
MonoAppDomain *ad;
MonoClass *class;
+ MonoString *arg;
+
+ mono_marshal_init ();
+ mono_install_assembly_preload_hook (mono_domain_assembly_preload, NULL);
mono_install_assembly_load_hook (mono_domain_fire_assembly_load, NULL);
+ mono_install_lookup_dynamic_token (mono_reflection_lookup_dynamic_token);
+
+ mono_thread_init (start_cb, attach_cb);
class = mono_class_from_name (mono_defaults.corlib, "System", "AppDomainSetup");
setup = (MonoAppDomainSetup *) mono_object_new (domain, class);
domain->domain = ad;
domain->setup = setup;
- mono_delegate_semaphore = CreateSemaphore (NULL, 0, 0x7fffffff, NULL);
- g_assert (mono_delegate_semaphore != INVALID_HANDLE_VALUE);
InitializeCriticalSection (&mono_delegate_section);
- mono_thread_init (domain, start_cb, attach_cb);
+ mono_context_init (domain);
+ mono_context_set (domain->default_context);
+
+ mono_type_initialization_init ();
+
+
+ /*
+ * Create an instance early since we can't do it when there is no memory.
+ */
+ arg = mono_string_new (domain, "Out of memory");
+ domain->out_of_memory_ex = mono_exception_from_name_two_strings (mono_defaults.corlib, "System", "OutOfMemoryException", arg, NULL);
+
+ /*
+ * These two are needed because the signal handlers might be executing on
+ * an alternate stack, and Boehm GC can't handle that.
+ */
+ arg = mono_string_new (domain, "A null value was found where an object instance was required");
+ domain->null_reference_ex = mono_exception_from_name_two_strings (mono_defaults.corlib, "System", "NullReferenceException", arg, NULL);
+ arg = mono_string_new (domain, "The requested operation caused a stack overflow.");
+ domain->stack_overflow_ex = mono_exception_from_name_two_strings (mono_defaults.corlib, "System", "StackOverflowException", arg, NULL);
/* GC init has to happen after thread init */
mono_gc_init ();
return;
}
-void
-mono_runtime_cleanup (MonoDomain *domain)
+static int
+mono_get_corlib_version (void)
{
- mono_thread_cleanup ();
+ MonoClass *klass;
+ MonoClassField *field;
+ MonoObject *value;
+
+ klass = mono_class_from_name (mono_defaults.corlib, "System", "Environment");
+ mono_class_init (klass);
+ field = mono_class_get_field_from_name (klass, "mono_corlib_version");
+ if (!field)
+ return -1;
+ if (! (field->type->attrs & FIELD_ATTRIBUTE_STATIC))
+ return -1;
+ value = mono_field_get_value_object (mono_domain_get (), field, NULL);
+ return *(gint32*)((gchar*)value + sizeof (MonoObject));
+}
- /* Do this after the thread cleanup, because subthreads might
- * still be doing socket calls.
- */
- mono_network_cleanup ();
+const char*
+mono_check_corlib_version (void)
+{
+ int version = mono_get_corlib_version ();
+ if (version != MONO_CORLIB_VERSION)
+ return g_strdup_printf ("expected corlib version %d, found %d.", MONO_CORLIB_VERSION, version);
+ else
+ return NULL;
}
void
-ves_icall_System_AppDomainSetup_InitAppDomainSetup (MonoAppDomainSetup *setup)
+mono_context_init (MonoDomain *domain)
{
- MonoDomain* domain = mono_domain_get ();
- MonoAssembly *assembly;
- gchar *str;
-
- MONO_ARCH_SAVE_REGS;
-
- assembly = domain->entry_assembly;
- g_assert (assembly);
+ MonoClass *class;
+ MonoAppContext *context;
- setup->application_base = mono_string_new (domain, assembly->basedir);
- str = g_strconcat (assembly->basedir, assembly->aname.name,
- ".exe.config", NULL);
- setup->configuration_file = mono_string_new (domain, str);
- g_free (str);
+ class = mono_class_from_name (mono_defaults.corlib, "System.Runtime.Remoting.Contexts", "Context");
+ context = (MonoAppContext *) mono_object_new (domain, class);
+ context->domain_id = domain->domain_id;
+ context->context_id = 0;
+ domain->default_context = context;
}
-/*
- * invokes a method in a specific domain.
+/* This must not be called while there are still running threads executing
+ * managed code.
*/
-static MonoObject*
-mono_runtime_invoke_in_domain (MonoDomain *domain, MonoMethod *method, void *obj,
- void **params, MonoObject **exc)
+void
+mono_runtime_cleanup (MonoDomain *domain)
{
- MonoDomain *cur = mono_domain_get ();
- MonoObject **real_exc, *default_exc;
- MonoObject *res;
+ shutting_down = TRUE;
- if (domain == cur)
- return mono_runtime_invoke (method, obj, params, exc);
+ /* This ends up calling any pending pending (for at most 2 seconds) */
+ mono_gc_cleanup ();
- if (!exc)
- real_exc = &default_exc;
- else
- real_exc = exc;
-
- *real_exc = NULL;
- mono_domain_set (domain);
- res = mono_runtime_invoke (method, obj, params, real_exc);
- mono_domain_set (cur);
+ mono_network_cleanup ();
+}
- if (*real_exc) {
- /* transfer Exception to the right domain */
- *real_exc = mono_domain_transfer_object (domain, cur, *real_exc);
+static MonoDomainFunc quit_function = NULL;
- if (!exc)
- mono_raise_exception ((MonoException *)*real_exc);
+void
+mono_runtime_install_cleanup (MonoDomainFunc func)
+{
+ quit_function = func;
+}
- }
+void
+mono_runtime_quit ()
+{
+ if (quit_function != NULL)
+ quit_function (mono_root_domain, NULL);
+}
- return res;
+gboolean
+mono_runtime_is_shutting_down (void)
+{
+ return shutting_down;
}
-static MonoObject *
-mono_domain_transfer_array (MonoDomain *src, MonoDomain *dst, MonoArray *ao)
+gboolean
+mono_domain_has_type_resolve (MonoDomain *domain)
{
- MonoObject *res = NULL;
- MonoClass *klass;
- int esize, ecount, i;
- guint32 *sizes;
-
- klass = ao->obj.vtable->klass;
+ static MonoClassField *field = NULL;
+ MonoObject *o;
- esize = mono_array_element_size (klass);
- if (ao->bounds == NULL) {
- ecount = mono_array_length (ao);
- res = (MonoObject *)mono_array_new_full (dst, klass, &ecount, NULL);
- } else {
- sizes = alloca (klass->rank * sizeof(guint32) * 2);
- ecount = 1;
- for (i = 0; i < klass->rank; ++i) {
- sizes [i] = ao->bounds [i].length;
- ecount *= ao->bounds [i].length;
- sizes [i + klass->rank] = ao->bounds [i].lower_bound;
- }
- res = (MonoObject *)mono_array_new_full (dst, klass, sizes, sizes + klass->rank);
- }
- if (klass->element_class->valuetype) {
- if (klass->element_class->blittable) {
- memcpy (((MonoArray *)res)->vector, ao->vector, esize * ecount);
- } else {
- for (i = 0; i < ecount; i++) {
- MonoObject *s, *d;
- gpointer *src_ea = (gpointer *)mono_array_addr_with_size (ao, esize, i);
- gpointer *dst_ea = (gpointer *)mono_array_addr_with_size ((MonoArray *)res, esize, i);
- s = mono_value_box (src, klass->element_class, src_ea);
- d = mono_domain_transfer_object (src, dst, s);
- memcpy (dst_ea, (char *)d + sizeof(MonoObject), esize);
- }
- }
- } else {
- g_assert (esize == sizeof (gpointer));
- for (i = 0; i < ecount; i++) {
- gpointer *src_ea = (gpointer *)mono_array_addr_with_size (ao, esize, i);
- gpointer *dst_ea = (gpointer *)mono_array_addr_with_size ((MonoArray *)res, esize, i);
- *dst_ea = mono_domain_transfer_object (src, dst, *src_ea);
- }
+ if (field == NULL) {
+ MonoClass *klass = mono_defaults.appdomain_class;
+ int i;
+
+ for (i = 0; i < klass->field.count; ++i)
+ if (strcmp (klass->fields [i].name, "TypeResolve") == 0)
+ field = &klass->fields [i];
+ g_assert (field);
}
- return res;
+
+ mono_field_get_value ((MonoObject*)(domain->domain), field, &o);
+ return o != NULL;
}
-/**
- * mono_domain_transfer_object:
- * @src: the source domain
- * @dst: the destination domain
- * @obj: the object to transfer
- *
- * This function is used to transfer objects between domains. This is done by
- * marshalling or serialisation.
- */
-static MonoObject *
-mono_domain_transfer_object (MonoDomain *src, MonoDomain *dst, MonoObject *obj)
+MonoReflectionAssembly *
+mono_domain_try_type_resolve (MonoDomain *domain, char *name, MonoObject *tb)
{
- MonoClass *sic = mono_defaults.serializationinfo_class;
MonoClass *klass;
- MonoObject *res = NULL;
- int i;
-
- if (!obj)
- return NULL;
+ void *params [1];
+ static MonoMethod *method = NULL;
- g_assert (obj->vtable->domain == src);
-
- klass = obj->vtable->klass;
-
- /* some special cases */
- if (klass == mono_defaults.string_class) {
- MonoString *str = (MonoString *)obj;
- return (MonoObject *)mono_string_new_utf16 (dst,
- (const guint16 *)mono_string_chars (str), str->length);
- }
-
- if (klass == mono_defaults.monotype_class)
- return (MonoObject *) mono_type_get_object (dst, ((MonoReflectionType *)obj)->type);
-
- if (MONO_CLASS_IS_ARRAY (klass))
- return mono_domain_transfer_array (src, dst, (MonoArray *)obj);
-
- if (mono_object_isinst (obj, mono_defaults.iserializeable_class)) {
- static MonoMethod *serinfo_ctor1 = NULL, *serinfo_ctor2 = NULL, *get_entries = NULL;
- MonoMethod *get_object_data, *ser_ctor;
- MonoObject *src_serinfo, *dst_serinfo;
- void *pa [2];
- MonoStreamingContext ctx;
- MonoArray *entries, *trans_entries;
- int len;
-
- /* get a pointer to the GetObjectData method */
- get_object_data = klass->vtable [klass->interface_offsets [mono_defaults.iserializeable_class->interface_id]];
- g_assert (get_object_data);
-
- src_serinfo = mono_object_new (src, sic);
-
- if (!serinfo_ctor1) {
- for (i = 0; i < sic->method.count; ++i) {
- if (!strcmp (".ctor", sic->methods [i]->name) &&
- sic->methods [i]->signature->param_count == 1) {
- serinfo_ctor1 = sic->methods [i];
- break;
- }
- }
- g_assert (serinfo_ctor1);
- }
-
- if (!serinfo_ctor2) {
- for (i = 0; i < sic->method.count; ++i) {
- if (!strcmp (".ctor", sic->methods [i]->name) &&
- sic->methods [i]->signature->param_count == 2 &&
- sic->methods [i]->signature->params [1]->type == MONO_TYPE_SZARRAY) {
- serinfo_ctor2 = sic->methods [i];
- break;
- }
- }
- g_assert (serinfo_ctor2);
- }
-
- if (!get_entries) {
- for (i = 0; i < sic->method.count; ++i) {
- if (!strcmp ("get_entries", sic->methods [i]->name) &&
- sic->methods [i]->signature->param_count == 0) {
- get_entries = sic->methods [i];
- break;
- }
- }
- g_assert (get_entries);
- }
+ g_assert (domain != NULL && ((name != NULL) || (tb != NULL)));
- pa [0] = mono_type_get_object (src, &klass->byval_arg);
- mono_runtime_invoke_in_domain (src, serinfo_ctor1, src_serinfo, pa, NULL);
-
- ctx.additional = NULL;
- ctx.state = 128; /* CrossAppDomain */
- pa [0] = src_serinfo;
- pa [1] = &ctx;
- mono_runtime_invoke_in_domain (src, get_object_data, obj, pa, NULL);
-
- entries = (MonoArray *)mono_runtime_invoke_in_domain (src, get_entries, src_serinfo, NULL, NULL);
-
- g_assert (src_serinfo->vtable->domain == src);
- g_assert (entries->obj.vtable->domain == src);
-
- /* transfer all SerializationEntry objects */
- len = mono_array_length ((MonoArray*)entries);
- trans_entries = mono_array_new (dst, entries->obj.vtable->klass->element_class, len);
-
- for (i = 0; i < len; i++) {
- MonoSerializationEntry *s, *d;
- s = (MonoSerializationEntry *)mono_array_addr_with_size (entries,
- sizeof (MonoSerializationEntry), i);
- d = (MonoSerializationEntry *)mono_array_addr_with_size (trans_entries,
- sizeof (MonoSerializationEntry), i);
- d->name = (MonoString *)mono_domain_transfer_object (src, dst, (MonoObject *)s->name);
- d->value = mono_domain_transfer_object (src, dst, s->value);
- d->type = (MonoReflectionType *)mono_domain_transfer_object (src, dst, (MonoObject *)s->type);
- }
+ if (method == NULL) {
+ klass = domain->domain->mbr.obj.vtable->klass;
+ g_assert (klass);
- dst_serinfo = mono_object_new (dst, sic);
-
- pa [0] = mono_type_get_object (dst, &klass->byval_arg);
- pa [1] = trans_entries;
- mono_runtime_invoke_in_domain (dst, serinfo_ctor2, dst_serinfo, pa, NULL);
-
- ser_ctor = NULL;
- for (i = 0; i < klass->method.count; i++) {
- MonoMethod *t = klass->methods [i];
- if (!strcmp (t->name, ".ctor") && t->signature->param_count == 2 &&
- mono_metadata_type_equal (t->signature->params [0],
- &mono_defaults.serializationinfo_class->byval_arg) &&
- mono_metadata_type_equal (t->signature->params [1],
- &mono_defaults.streamingcontext_class->byval_arg))
- ser_ctor = t;
+ method = look_for_method_by_name (klass, "DoTypeResolve");
+ if (method == NULL) {
+ g_warning ("Method AppDomain.DoTypeResolve not found.\n");
+ return NULL;
}
- g_assert (ser_ctor);
-
- res = mono_object_new (dst, klass);
-
- ctx.additional = NULL;
- ctx.state = 128; /* CrossAppDomain */
- pa [0] = dst_serinfo;
- pa [1] = &ctx;
- mono_runtime_invoke_in_domain (dst, ser_ctor, res, pa, NULL);
-
- return res;
- }
-
- if (!(klass->flags & TYPE_ATTRIBUTE_SERIALIZABLE)) {
- MonoException *exc = NULL;
- char *msg;
-
- msg = g_strdup_printf ("klass \"%s.%s\" is not serializable",
- klass->name_space, klass->name);
- exc = mono_get_exception_serialization (msg);
- g_free (msg);
-
- mono_raise_exception (exc);
}
- res = mono_object_new (dst, klass);
-
- for (i = 0; i < klass->field.count; i++) {
- MonoClassField *field = &klass->fields [i];
- MonoType *type = field->type;
- int size, align;
- char *src_ptr, *dst_ptr;
- int simple_type;
-
- if (type->attrs & FIELD_ATTRIBUTE_STATIC ||
- type->attrs & FIELD_ATTRIBUTE_NOT_SERIALIZED)
- continue;
-
- size = mono_type_size (type, &align);
-
- dst_ptr = (char*)res + field->offset;
- src_ptr = (char *)obj + field->offset;
+ if (name)
+ *params = (MonoObject*)mono_string_new (mono_domain_get (), name);
+ else
+ *params = tb;
+ return (MonoReflectionAssembly *) mono_runtime_invoke (method, domain->domain, params, NULL);
+}
- g_assert (!type->byref);
-
- simple_type = type->type;
- handle_enum:
- switch (simple_type) {
- case MONO_TYPE_BOOLEAN:
- case MONO_TYPE_CHAR:
- case MONO_TYPE_I1:
- case MONO_TYPE_U1:
- case MONO_TYPE_I2:
- case MONO_TYPE_U2:
- case MONO_TYPE_I4:
- case MONO_TYPE_U4:
- case MONO_TYPE_I:
- case MONO_TYPE_U:
- case MONO_TYPE_I8:
- case MONO_TYPE_U8:
- case MONO_TYPE_R4:
- case MONO_TYPE_R8:
- memcpy (dst_ptr, src_ptr, size);
- break;
- case MONO_TYPE_OBJECT:
- case MONO_TYPE_ARRAY:
- case MONO_TYPE_SZARRAY:
- case MONO_TYPE_CLASS:
- case MONO_TYPE_STRING: {
- *(MonoObject **)dst_ptr = mono_domain_transfer_object (src, dst, *(MonoObject **)src_ptr);
- break;
- }
- case MONO_TYPE_VALUETYPE: {
- MonoObject *boxed_src, *tmp;
+/*
+ * mono_domain_set:
+ *
+ * Set the current appdomain to @domain. If @force is set, set it even
+ * if it is being unloaded.
+ * Returns:
+ * - TRUE on success
+ * - FALSE if the domain is being unloaded
+ */
+gboolean
+mono_domain_set (MonoDomain *domain, gboolean force)
+{
+ if (!force && (domain->state == MONO_APPDOMAIN_UNLOADING || domain->state == MONO_APPDOMAIN_UNLOADED))
+ return FALSE;
- if (type->data.klass->enumtype) {
- simple_type = type->data.klass->enum_basetype->type;
- goto handle_enum;
- }
- boxed_src = mono_value_box (src, type->data.klass, src_ptr);
- tmp = mono_domain_transfer_object (src, dst, boxed_src);
- memcpy (dst_ptr, (char *)tmp + sizeof (MonoObject), size);
- break;
- }
- default:
- g_assert_not_reached ();
- }
- }
+ mono_domain_set_internal (domain);
- return res;
+ return TRUE;
}
MonoObject *
ves_icall_System_AppDomain_GetData (MonoAppDomain *ad, MonoString *name)
{
MonoDomain *add = ad->data;
- MonoDomain *cur = mono_domain_get ();
MonoObject *o;
char *str;
str = mono_string_to_utf8 (name);
mono_domain_lock (add);
+
if (!strcmp (str, "APPBASE"))
o = (MonoObject *)add->setup->application_base;
else if (!strcmp (str, "APP_CONFIG_FILE"))
if (!o)
return NULL;
- return mono_domain_transfer_object (add, cur, o);
+ return o;
}
void
ves_icall_System_AppDomain_SetData (MonoAppDomain *ad, MonoString *name, MonoObject *data)
{
MonoDomain *add = ad->data;
- MonoDomain *cur = mono_domain_get ();
- MonoObject *o;
MONO_ARCH_SAVE_REGS;
g_assert (ad != NULL);
g_assert (name != NULL);
- o = mono_domain_transfer_object (cur, add, data);
-
mono_domain_lock (add);
- mono_g_hash_table_insert (add->env, name, o);
+
+ mono_g_hash_table_insert (add->env, name, data);
mono_domain_unlock (add);
}
MonoAppDomain *
ves_icall_System_AppDomain_createDomain (MonoString *friendly_name, MonoAppDomainSetup *setup)
{
- MonoDomain *domain = mono_domain_get ();
+ /*MonoDomain *domain = mono_domain_get (); */
MonoClass *adclass;
MonoAppDomain *ad;
MonoDomain *data;
MONO_ARCH_SAVE_REGS;
adclass = mono_class_from_name (mono_defaults.corlib, "System", "AppDomain");
-
+
/* FIXME: pin all those objects */
- ad = (MonoAppDomain *) mono_object_new (domain, adclass);
- ad->data = data = mono_domain_create ();
+ data = mono_domain_create();
+
+ ad = (MonoAppDomain *) mono_object_new (data, adclass);
+ ad->data = data;
data->domain = ad;
data->setup = setup;
data->friendly_name = mono_string_to_utf8 (friendly_name);
+ data->out_of_memory_ex = mono_exception_from_name_domain (data, mono_defaults.corlib, "System", "OutOfMemoryException");
+
+ mono_context_init (data);
/* FIXME: what to do next ? */
g_assert (domain != NULL && fname != NULL);
- klass = domain->domain->object.vtable->klass;
+ klass = domain->domain->mbr.obj.vtable->klass;
g_assert (klass);
method = look_for_method_by_name (klass, "DoAssemblyResolve");
{
gint i;
- if (g_hash_table_lookup (domain->assemblies, ass->aname.name))
- return; /* This is ok while no lazy loading of assemblies */
+ if (!ass->aname.name)
+ return;
mono_domain_lock (domain);
- g_hash_table_insert (domain->assemblies, ass->aname.name, ass);
+
+ if (g_hash_table_lookup (domain->assemblies, ass->aname.name)) {
+ mono_domain_unlock (domain);
+ return; /* This is ok while no lazy loading of assemblies */
+ }
+
+ g_hash_table_insert (domain->assemblies, (gpointer) ass->aname.name, ass);
mono_domain_unlock (domain);
- for (i = 0; ass->image->references [i] != NULL; i++)
- add_assemblies_to_domain (domain, ass->image->references [i]);
+ if (ass->image->references)
+ for (i = 0; ass->image->references [i] != NULL; i++)
+ add_assemblies_to_domain (domain, ass->image->references [i]);
}
static void
MonoMethod *method;
void *params [1];
- klass = domain->domain->object.vtable->klass;
+ klass = domain->domain->mbr.obj.vtable->klass;
+
method = look_for_method_by_name (klass, "DoAssemblyLoad");
if (method == NULL) {
mono_runtime_invoke (method, domain->domain, params, NULL);
}
+static gchar *
+reduce_path (const gchar *dirname)
+{
+ gchar **parts;
+ gchar *part;
+ GList *list, *tmp;
+ GString *result;
+ gchar *res;
+ gint i;
+
+ parts = g_strsplit (dirname, G_DIR_SEPARATOR_S, 0);
+ list = NULL;
+ for (i = 0; (part = parts [i]) != NULL; i++) {
+ if (!strcmp (part, "."))
+ continue;
+
+ if (!strcmp (part, "..")) {
+ if (list && list->next) /* Don't remove root */
+ list = g_list_delete_link (list, list);
+ } else {
+ list = g_list_prepend (list, part);
+ }
+ }
+
+ result = g_string_new ("");
+ list = g_list_reverse (list);
+
+ for (tmp = list; tmp; tmp = tmp->next) {
+ gchar *data = (gchar *) tmp->data;
+
+ if (data && *data)
+ g_string_append_printf (result, "%c%s", G_DIR_SEPARATOR,
+ (char *) tmp->data);
+ }
+
+ res = result->str;
+ g_string_free (result, FALSE);
+ g_list_free (list);
+ g_strfreev (parts);
+ return res;
+}
+
+static void
+set_domain_search_path (MonoDomain *domain)
+{
+ MonoAppDomainSetup *setup;
+ gchar **tmp;
+ gchar *utf8;
+ gint i;
+ gint npaths = 0;
+ gchar **pvt_split = NULL;
+ GError *error = NULL;
+ gint appbaselen = -1;
+
+ if ((domain->search_path != NULL) && !domain->setup->path_changed)
+ return;
+
+ setup = domain->setup;
+ if (!setup->application_base)
+ return; /* Must set application base to get private path working */
+
+ npaths++;
+ if (setup->private_bin_path) {
+ utf8 = mono_string_to_utf8 (setup->private_bin_path);
+ pvt_split = g_strsplit (utf8, G_SEARCHPATH_SEPARATOR_S, 1000);
+ g_free (utf8);
+ for (tmp = pvt_split; *tmp; tmp++, npaths++);
+ }
+
+ if (!npaths) {
+ if (pvt_split)
+ g_strfreev (pvt_split);
+ /*
+ * Don't do this because the first time is called, the domain
+ * setup is not finished.
+ *
+ * domain->search_path = g_malloc (sizeof (char *));
+ * domain->search_path [0] = NULL;
+ */
+ return;
+ }
+
+ if (domain->search_path)
+ g_strfreev (domain->search_path);
+
+ domain->search_path = tmp = g_malloc ((npaths + 1) * sizeof (gchar *));
+ tmp [npaths] = NULL;
+
+ *tmp = mono_string_to_utf8 (setup->application_base);
+
+ /* FIXME: is this needed? */
+ if (strncmp (*tmp, "file://", 7) == 0) {
+ gchar *file = *tmp;
+ gchar *uri = *tmp;
+ gchar *tmpuri;
+
+ if (uri [7] != '/')
+ uri = g_strdup_printf ("file:///%s", uri + 7);
+
+ tmpuri = uri;
+ uri = mono_escape_uri_string (tmpuri);
+ *tmp = g_filename_from_uri (uri, NULL, &error);
+ g_free (uri);
+
+ if (tmpuri != file)
+ g_free (tmpuri);
+
+ if (error != NULL) {
+ g_warning ("%s\n", error->message);
+ g_error_free (error);
+ *tmp = file;
+ } else {
+ g_free (file);
+ }
+ }
+
+ for (i = 1; pvt_split && i < npaths; i++) {
+ tmp [i] = g_build_filename (tmp [0], pvt_split [i - 1], NULL);
+ if (strchr (tmp [i], '.')) {
+ gchar *reduced;
+ gchar *freeme;
+
+ reduced = reduce_path (tmp [i]);
+ if (appbaselen == -1)
+ appbaselen = strlen (tmp [0]);
+
+ if (strncmp (tmp [0], reduced, appbaselen)) {
+ g_free (reduced);
+ g_free (tmp [i]);
+ tmp [i] = g_strdup ("");
+ continue;
+ }
+
+ freeme = tmp [i];
+ tmp [i] = reduced;
+ g_free (freeme);
+ }
+ }
+
+ if (setup->private_bin_path_probe != NULL) {
+ g_free (tmp [0]);
+ tmp [0] = g_strdup ("");
+ }
+
+ domain->setup->path_changed = FALSE;
+
+ g_strfreev (pvt_split);
+}
+
+static gboolean
+try_load_from (MonoAssembly **assembly, const gchar *path1, const gchar *path2,
+ const gchar *path3, const gchar *path4)
+{
+ gchar *fullpath;
+
+ *assembly = NULL;
+ fullpath = g_build_filename (path1, path2, path3, path4, NULL);
+ if (g_file_test (fullpath, G_FILE_TEST_IS_REGULAR))
+ *assembly = mono_assembly_open (fullpath, NULL);
+
+ g_free (fullpath);
+ return (*assembly != NULL);
+}
+
+static MonoAssembly *
+real_load (gchar **search_path, const gchar *culture, const gchar *name)
+{
+ MonoAssembly *result = NULL;
+ gchar **path;
+ gchar *filename;
+ const gchar *local_culture;
+ gint len;
+
+ if (!culture || *culture == '\0') {
+ local_culture = "";
+ } else {
+ local_culture = culture;
+ }
+
+ filename = g_strconcat (name, ".dll", NULL);
+ len = strlen (filename);
+
+ for (path = search_path; *path; path++) {
+ if (**path == '\0')
+ continue; /* Ignore empty ApplicationBase */
+
+ /* See test cases in bug #58992 and bug #57710 */
+ /* 1st try: [culture]/[name].dll (culture may be empty) */
+ strcpy (filename + len - 4, ".dll");
+ if (try_load_from (&result, *path, local_culture, "", filename))
+ break;
+
+ /* 2nd try: [culture]/[name].exe (culture may be empty) */
+ strcpy (filename + len - 4, ".exe");
+ if (try_load_from (&result, *path, local_culture, "", filename))
+ break;
+
+ /* 3rd try: [culture]/[name]/[name].dll (culture may be empty) */
+ strcpy (filename + len - 4, ".dll");
+ if (try_load_from (&result, *path, local_culture, name, filename))
+ break;
+
+ /* 4th try: [culture]/[name]/[name].exe (culture may be empty) */
+ strcpy (filename + len - 4, ".exe");
+ if (try_load_from (&result, *path, local_culture, name, filename))
+ break;
+ }
+
+ g_free (filename);
+ return result;
+}
+
+/*
+ * Try loading the assembly from ApplicationBase and PrivateBinPath
+ * and then from assemblies_path if any.
+ */
+static MonoAssembly *
+mono_domain_assembly_preload (MonoAssemblyName *aname,
+ gchar **assemblies_path,
+ gpointer user_data)
+{
+ MonoDomain *domain = mono_domain_get ();
+ MonoAssembly *result = NULL;
+
+ set_domain_search_path (domain);
+
+ if (domain->search_path && domain->search_path [0] != NULL) {
+ result = real_load (domain->search_path, aname->culture, aname->name);
+ }
+
+ if (result == NULL && assemblies_path && assemblies_path [0] != NULL) {
+ result = real_load (assemblies_path, aname->culture, aname->name);
+ }
+
+ return NULL;
+}
+
MonoReflectionAssembly *
ves_icall_System_Reflection_Assembly_LoadFrom (MonoString *fname)
{
MONO_ARCH_SAVE_REGS;
+ if (fname == NULL) {
+ MonoException *exc = mono_get_exception_argument_null ("assemblyFile");
+ mono_raise_exception (exc);
+ }
+
name = filename = mono_string_to_utf8 (fname);
- /* FIXME: move uri handling to mono_assembly_open */
- if (strncmp (filename, "file://", 7) == 0)
- filename += 7;
-
ass = mono_assembly_open (filename, &status);
g_free (name);
return mono_assembly_get_object (domain, ass);
}
+static void
+free_assembly_name (MonoAssemblyName *aname)
+{
+ if (aname == NULL)
+ return;
+
+ g_free ((void *) aname->name);
+ g_free ((void *) aname->culture);
+ g_free ((void *) aname->hash_value);
+}
+
+static gboolean
+get_info_from_assembly_name (MonoString *assRef, MonoAssemblyName *aname)
+{
+ gchar *name;
+ gchar *value;
+ gchar **parts;
+ gchar **tmp;
+ gint major, minor, build, revision;
+
+ memset (aname, 0, sizeof (MonoAssemblyName));
+
+ name = mono_string_to_utf8 (assRef);
+ parts = tmp = g_strsplit (name, ",", 4);
+ g_free (name);
+ if (!tmp || !*tmp) {
+ g_strfreev (tmp);
+ return FALSE;
+ }
+
+ value = g_strstrip (*tmp);
+ /* g_print ("Assembly name: %s\n", value); */
+ aname->name = g_strdup (value);
+ tmp++;
+ if (!*tmp) {
+ g_strfreev (parts);
+ return TRUE;
+ }
+
+ while (*tmp) {
+ value = g_strstrip (*tmp);
+ if (!g_ascii_strncasecmp (value, "Version=", 8)) {
+ if (sscanf (value + 8, "%u.%u.%u.%u",
+ &major, &minor, &build, &revision) != 4) {
+ g_strfreev (parts);
+ return FALSE;
+ }
+ /* g_print ("Version: %u.%u.%u.%u\n", major, minor, build, revision); */
+ aname->major = major;
+ aname->minor = minor;
+ aname->build = build;
+ aname->revision = revision;
+ tmp++;
+ continue;
+ }
+
+ if (!g_ascii_strncasecmp (value, "Culture=", 8)) {
+ gchar *t = g_strdup (value + 8);
+ g_strchug (t);
+ aname->culture = g_strdup (g_strchomp (t));
+ tmp++;
+ g_free (t);
+ if (g_strcasecmp (aname->culture, "neutral") == 0) {
+ g_free ((void *) aname->culture);
+ aname->culture = g_strdup ("");
+ }
+ continue;
+ }
+
+ if (!g_ascii_strncasecmp (value, "PublicKeyToken=", 15)) {
+ tmp++;
+ value += 15;
+ if (*value && strncmp (value, "null", 4)) {
+ gchar *t = g_strdup (value);
+ g_strchug (t);
+ aname->public_tok_value = g_strdup (g_strchomp (value));
+ g_free (t);
+ }
+ continue;
+ }
+
+ g_strfreev (parts);
+ return FALSE;
+ }
+
+ g_strfreev (parts);
+ return TRUE;
+}
+
+MonoReflectionAssembly *
+ves_icall_System_AppDomain_LoadAssemblyRaw (MonoAppDomain *ad,
+ MonoArray *raw_assembly,
+ MonoArray *raw_symbol_store, MonoObject *evidence)
+{
+ MonoAssembly *ass;
+ MonoDomain *domain = ad->data;
+ MonoImageOpenStatus status;
+ guint32 raw_assembly_len = mono_array_length (raw_assembly);
+ MonoImage *image = mono_image_open_from_data (mono_array_addr (raw_assembly, gchar, 0), raw_assembly_len, TRUE, NULL);
+
+ if (raw_symbol_store)
+ mono_raise_exception (mono_get_exception_not_implemented ("LoadAssemblyRaw: Raw Symbol Store not Implemented"));
+
+ if (!image) {
+ mono_raise_exception (mono_get_exception_bad_image_format (""));
+ return NULL;
+ }
+
+ ass = mono_assembly_load_from (image, "", &status);
+
+ if (!ass) {
+ mono_image_close (image);
+ mono_raise_exception (mono_get_exception_bad_image_format (""));
+ return NULL;
+ }
+
+ return mono_assembly_get_object (domain, ass);
+}
MonoReflectionAssembly *
-ves_icall_System_AppDomain_LoadAssembly (MonoAppDomain *ad, MonoReflectionAssemblyName *assRef, MonoObject *evidence)
+ves_icall_System_AppDomain_LoadAssembly (MonoAppDomain *ad, MonoString *assRef, MonoObject *evidence)
{
MonoDomain *domain = ad->data;
- char *name;
MonoImageOpenStatus status = MONO_IMAGE_OK;
MonoAssembly *ass;
MonoAssemblyName aname;
MONO_ARCH_SAVE_REGS;
- memset (&aname, 0, sizeof (aname));
-
/* FIXME : examine evidence? */
g_assert (assRef != NULL);
- g_assert (assRef->name != NULL);
- /* FIXME : examine version, culture info */
+ if (!get_info_from_assembly_name (assRef, &aname)) {
+ MonoException *exc;
- aname.name = name = mono_string_to_utf8 (assRef->name);
+ free_assembly_name (&aname);
+ /* This is a parse error... */
+ exc = mono_get_exception_file_not_found (assRef);
+ mono_raise_exception (exc);
+ }
ass = mono_assembly_load (&aname, NULL, &status);
-
- g_free (name);
+ free_assembly_name (&aname);
- if (!ass && (refass = try_assembly_resolve (domain, assRef->name)) == NULL){
+ if (!ass && (refass = try_assembly_resolve (domain, assRef)) == NULL){
/* FIXME: it doesn't make much sense since we really don't have a filename ... */
- MonoException *exc = mono_get_exception_file_not_found (assRef->name);
+ MonoException *exc = mono_get_exception_file_not_found (assRef);
mono_raise_exception (exc);
}
}
void
-ves_icall_System_AppDomain_Unload (MonoAppDomain *ad)
+ves_icall_System_AppDomain_InternalUnload (gint32 domain_id)
{
+ MonoDomain * domain = mono_domain_get_by_id (domain_id);
+
MONO_ARCH_SAVE_REGS;
- mono_domain_unload (ad->data, FALSE);
+ if (NULL == domain) {
+ MonoException *exc = mono_get_exception_execution_engine ("Failed to unload domain, domain id not found");
+ mono_raise_exception (exc);
+ }
+
+ if (domain == mono_root_domain) {
+ mono_raise_exception (mono_get_exception_cannot_unload_appdomain ("The default appdomain can not be unloaded."));
+ return;
+ }
+
+ /*
+ * Unloading seems to cause problems when running NUnit/NAnt, hence
+ * this workaround.
+ */
+ if (g_getenv ("MONO_NO_UNLOAD"))
+ return;
+
+ mono_domain_unload (domain);
+}
+
+gboolean
+ves_icall_System_AppDomain_InternalIsFinalizingForUnload (gint32 domain_id)
+{
+ MonoDomain *domain = mono_domain_get_by_id (domain_id);
+
+ if (!domain)
+ return TRUE;
+
+ return mono_domain_is_unloading (domain);
}
gint32
ves_icall_System_AppDomain_ExecuteAssembly (MonoAppDomain *ad, MonoString *file,
MonoObject *evidence, MonoArray *args)
{
- MonoDomain *cdom = mono_domain_get ();
MonoAssembly *assembly;
MonoImage *image;
MonoMethod *method;
- MonoObject *margs;
char *filename;
gint32 res;
MONO_ARCH_SAVE_REGS;
- mono_domain_set (ad->data);
-
filename = mono_string_to_utf8 (file);
assembly = mono_assembly_open (filename, NULL);
g_free (filename);
if (!assembly) {
mono_raise_exception ((MonoException *)mono_exception_from_name (
- mono_defaults.corlib, "System.IO", "FileNotFoundException"));
+ mono_defaults.corlib, "System.IO", "FileNotFoundException"));
}
image = assembly->image;
if (!method)
g_error ("No entry point method found in %s", image->name);
- margs = mono_domain_transfer_object (cdom, ad->data, (MonoObject *)args);
- if (!margs)
- margs = (MonoObject *) mono_array_new (ad->data, mono_defaults.string_class, 0);
- res = mono_runtime_exec_main (method, (MonoArray *)margs, NULL);
+ if (!args)
+ args = (MonoArray *) mono_array_new (ad->data, mono_defaults.string_class, 0);
- mono_domain_set (cdom);
+ res = mono_runtime_exec_main (method, (MonoArray *)args, NULL);
return res;
}
+gint32
+ves_icall_System_AppDomain_GetIDFromDomain (MonoAppDomain * ad)
+{
+ MONO_ARCH_SAVE_REGS;
+
+ return ad->data->domain_id;
+}
+
+MonoAppDomain *
+ves_icall_System_AppDomain_InternalSetDomain (MonoAppDomain *ad)
+{
+ MonoDomain *old_domain = mono_domain_get();
+
+ MONO_ARCH_SAVE_REGS;
+
+ if (!mono_domain_set (ad->data, FALSE))
+ mono_raise_exception (mono_get_exception_appdomain_unloaded ());
+
+ return old_domain->domain;
+}
+
+MonoAppDomain *
+ves_icall_System_AppDomain_InternalSetDomainByID (gint32 domainid)
+{
+ MonoDomain *current_domain = mono_domain_get ();
+ MonoDomain *domain = mono_domain_get_by_id (domainid);
+
+ MONO_ARCH_SAVE_REGS;
+
+ if (!domain || !mono_domain_set (domain, FALSE))
+ mono_raise_exception (mono_get_exception_appdomain_unloaded ());
+
+ return current_domain->domain;
+}
+
+void
+ves_icall_System_AppDomain_InternalPushDomainRef (MonoAppDomain *ad)
+{
+ MONO_ARCH_SAVE_REGS;
+
+ mono_thread_push_appdomain_ref (ad->data);
+}
+
+void
+ves_icall_System_AppDomain_InternalPushDomainRefByID (gint32 domain_id)
+{
+ MonoDomain *domain = mono_domain_get_by_id (domain_id);
+
+ MONO_ARCH_SAVE_REGS;
+
+ if (!domain)
+ /*
+ * Raise an exception to prevent the managed code from executing a pop
+ * later.
+ */
+ mono_raise_exception (mono_get_exception_appdomain_unloaded ());
+
+ mono_thread_push_appdomain_ref (domain);
+}
+
+void
+ves_icall_System_AppDomain_InternalPopDomainRef (void)
+{
+ MONO_ARCH_SAVE_REGS;
+
+ mono_thread_pop_appdomain_ref ();
+}
+
+MonoAppContext *
+ves_icall_System_AppDomain_InternalGetContext ()
+{
+ MONO_ARCH_SAVE_REGS;
+
+ return mono_context_get ();
+}
+
+MonoAppContext *
+ves_icall_System_AppDomain_InternalGetDefaultContext ()
+{
+ MONO_ARCH_SAVE_REGS;
+
+ return mono_domain_get ()->default_context;
+}
+
+MonoAppContext *
+ves_icall_System_AppDomain_InternalSetContext (MonoAppContext *mc)
+{
+ MonoAppContext *old_context = mono_context_get ();
+
+ MONO_ARCH_SAVE_REGS;
+
+ mono_context_set (mc);
+
+ return old_context;
+}
+
+MonoString *
+ves_icall_System_AppDomain_InternalGetProcessGuid (MonoString* newguid)
+{
+ mono_domain_lock (mono_root_domain);
+ if (process_guid_set) {
+ mono_domain_unlock (mono_root_domain);
+ return mono_string_new_utf16 (mono_domain_get (), process_guid, sizeof(process_guid)/2);
+ }
+ memcpy (process_guid, mono_string_chars(newguid), sizeof(process_guid));
+ process_guid_set = TRUE;
+ mono_domain_unlock (mono_root_domain);
+ return newguid;
+}
+
+gboolean
+mono_domain_is_unloading (MonoDomain *domain)
+{
+ if (domain->state == MONO_APPDOMAIN_UNLOADING || domain->state == MONO_APPDOMAIN_UNLOADED)
+ return TRUE;
+ else
+ return FALSE;
+}
+
+static void
+clear_cached_vtable (gpointer key, gpointer value, gpointer user_data)
+{
+ MonoClass *klass = (MonoClass*)key;
+ MonoDomain *domain = (MonoDomain*)user_data;
+ MonoVTable *vt;
+
+ vt = klass->cached_vtable;
+ if (vt && vt->domain == domain)
+ klass->cached_vtable = NULL;
+}
+
+typedef struct unload_data {
+ MonoDomain *domain;
+ char *failure_reason;
+} unload_data;
+
+static guint32
+unload_thread_main (void *arg)
+{
+ unload_data *data = (unload_data*)arg;
+ MonoDomain *domain = data->domain;
+
+ /*
+ * FIXME: Abort our parent thread last, so we can return a failure
+ * indication if aborting times out.
+ */
+ if (!mono_threads_abort_appdomain_threads (domain, 10000)) {
+ data->failure_reason = g_strdup_printf ("Aborting of threads in domain %s timed out.", domain->friendly_name);
+ return 1;
+ }
+
+ /* Finalize all finalizable objects in the doomed appdomain */
+ if (!mono_domain_finalize (domain, 10000)) {
+ data->failure_reason = g_strdup_printf ("Finalization of domain %s timed out.", domain->friendly_name);
+ return 1;
+ }
+
+ /* Clear references to our vtables in class->cached_vtable */
+ mono_domain_lock (domain);
+ mono_g_hash_table_foreach (domain->class_vtable_hash, clear_cached_vtable,
+ domain);
+ mono_domain_unlock (domain);
+
+ domain->state = MONO_APPDOMAIN_UNLOADED;
+
+ //printf ("UNLOADED %s.\n", domain->friendly_name);
+
+ mono_domain_free (domain, FALSE);
+
+#ifdef HAVE_BOEHM_GC
+ GC_gcollect ();
+#endif
+
+ return 0;
+}
+
+/*
+ * mono_domain_unload:
+ *
+ * Unloads an appdomain. Follows the process outlined in:
+ * http://blogs.gotdotnet.com/cbrumme
+ * If doing things the 'right' way is too hard or complex, we do it the
+ * 'simple' way, which means do everything needed to avoid crashes and
+ * memory leaks, but not much else.
+ */
+static void
+mono_domain_unload (MonoDomain *domain)
+{
+ HANDLE thread_handle;
+ guint32 tid;
+ MonoAppDomainState prev_state;
+ MonoMethod *method;
+ MonoObject *exc;
+ unload_data thread_data;
+
+ //printf ("UNLOAD STARTING FOR %s.\n", domain->friendly_name);
+
+ /* Atomically change our state to UNLOADING */
+ prev_state = InterlockedCompareExchange (&domain->state,
+ MONO_APPDOMAIN_UNLOADING,
+ MONO_APPDOMAIN_CREATED);
+ if (prev_state != MONO_APPDOMAIN_CREATED) {
+ if (prev_state == MONO_APPDOMAIN_UNLOADING)
+ mono_raise_exception (mono_get_exception_cannot_unload_appdomain ("Appdomain is already being unloaded."));
+ else
+ if (prev_state == MONO_APPDOMAIN_UNLOADED)
+ mono_raise_exception (mono_get_exception_cannot_unload_appdomain ("Appdomain is already unloaded."));
+ else
+ g_assert_not_reached ();
+ }
+
+ /* Notify OnDomainUnload listeners */
+ method = look_for_method_by_name (domain->domain->mbr.obj.vtable->klass, "DoDomainUnload");
+ g_assert (method);
+
+ exc = NULL;
+ mono_runtime_invoke (method, domain->domain, NULL, &exc);
+ if (exc) {
+ /* Roll back the state change */
+ domain->state = MONO_APPDOMAIN_CREATED;
+ mono_raise_exception ((MonoException*)exc);
+ }
+
+ thread_data.domain = domain;
+ thread_data.failure_reason = NULL;
+
+ /*
+ * 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 = CreateThread (NULL, 0, unload_thread_main, &thread_data, 0, &tid);
+#else
+ thread_handle = CreateThread (NULL, 0, unload_thread_main, &thread_data, CREATE_SUSPENDED, &tid);
+ ResumeThread (thread_handle);
+#endif
+
+ while (WaitForSingleObjectEx (thread_handle, INFINITE, FALSE) == WAIT_IO_COMPLETION)
+ ; /* wait for the thread */
+
+
+ if (thread_data.failure_reason) {
+ MonoException *ex;
+
+ ex = mono_get_exception_cannot_unload_appdomain (thread_data.failure_reason);
+ /* Roll back the state change */
+ domain->state = MONO_APPDOMAIN_CREATED;
+
+ g_warning (thread_data.failure_reason);
+
+ g_free (thread_data.failure_reason);
+
+ mono_raise_exception (ex);
+ }
+}
projects / mono.git / blobdiff