2008-07-11 Rodrigo Kumpera <rkumpera@novell.com>
[mono.git] / mono / metadata / appdomain.c
index 66d2952ebf3489bfad6040e5b433a734310ef332..a57df66f8b6d1710c68312580d9f9af4746df655 100644 (file)
 #include <errno.h>
 #include <sys/stat.h>
 #include <sys/types.h>
+#ifdef HAVE_UTIME_H
+#include <utime.h>
+#else
+#ifdef HAVE_SYS_UTIME_H
+#include <sys/utime.h>
+#endif
+#endif
 
-#include <mono/os/gc_wrapper.h>
-
+#include <mono/metadata/gc-internal.h>
 #include <mono/metadata/object.h>
 #include <mono/metadata/domain-internals.h>
 #include "mono/metadata/metadata-internals.h"
 #include <mono/utils/mono-logger.h>
 #include <mono/utils/mono-path.h>
 #include <mono/utils/mono-stdlib.h>
+#include <mono/utils/mono-io-portability.h>
 #ifdef PLATFORM_WIN32
 #include <direct.h>
 #endif
 
-#define MONO_CORLIB_VERSION 58
+/*
+ * This is the version number of the corlib-runtime interface. When
+ * making changes to this interface (by changing the layout
+ * of classes the runtime knows about, changing icall signature or
+ * semantics etc), increment this variable. Also increment the
+ * pair of this variable in mscorlib in:
+ *       mcs/class/mscorlib/System/Environment.cs
+ *
+ * Changes which are already detected at runtime, like the addition
+ * of icalls, do not require an increment.
+ */
+#define MONO_CORLIB_VERSION 68
+
+typedef struct
+{
+       int runtime_count;
+       int assemblybinding_count;
+       MonoDomain *domain;
+} RuntimeConfig;
 
 CRITICAL_SECTION mono_delegate_section;
 
@@ -74,6 +99,21 @@ add_assemblies_to_domain (MonoDomain *domain, MonoAssembly *ass, GHashTable *has
 static void
 mono_domain_unload (MonoDomain *domain);
 
+static MonoLoadFunc load_function = NULL;
+
+void
+mono_install_runtime_load (MonoLoadFunc func)
+{
+       load_function = func;
+}
+
+MonoDomain*
+mono_runtime_load (const char *filename, const char *runtime_version)
+{
+       g_assert (load_function);
+       return load_function (filename, runtime_version);
+}
+
 /**
  * mono_runtime_init:
  * @domain: domain returned by mono_init ()
@@ -94,8 +134,10 @@ mono_runtime_init (MonoDomain *domain, MonoThreadStartCB start_cb,
        MonoAppDomain *ad;
        MonoClass *class;
        MonoString *arg;
+
+       mono_portability_helpers_init ();
        
-       MONO_GC_PRE_INIT ();
+       mono_gc_base_init ();
        mono_monitor_init ();
        mono_thread_pool_init ();
        mono_marshal_init ();
@@ -151,7 +193,7 @@ mono_runtime_init (MonoDomain *domain, MonoThreadStartCB start_cb,
 
        /* mscorlib is loaded before we install the load hook */
        mono_domain_fire_assembly_load (mono_defaults.corlib->assembly, NULL);
-
+       
        return;
 }
 
@@ -484,6 +526,111 @@ ves_icall_System_AppDomain_getRootDomain ()
        return root->domain;
 }
 
+static char*
+get_attribute_value (const gchar **attribute_names, 
+                    const gchar **attribute_values, 
+                    const char *att_name)
+{
+       int n;
+       for (n = 0; attribute_names [n] != NULL; n++) {
+               if (strcmp (attribute_names [n], att_name) == 0)
+                       return g_strdup (attribute_values [n]);
+       }
+       return NULL;
+}
+
+static void
+start_element (GMarkupParseContext *context, 
+              const gchar         *element_name,
+              const gchar        **attribute_names,
+              const gchar        **attribute_values,
+              gpointer             user_data,
+              GError             **error)
+{
+       RuntimeConfig *runtime_config = user_data;
+       
+       if (strcmp (element_name, "runtime") == 0) {
+               runtime_config->runtime_count++;
+               return;
+       }
+
+       if (strcmp (element_name, "assemblyBinding") == 0) {
+               runtime_config->assemblybinding_count++;
+               return;
+       }
+       
+       if (runtime_config->runtime_count != 1 || runtime_config->assemblybinding_count != 1)
+               return;
+
+       if (strcmp (element_name, "probing") != 0)
+               return;
+
+       g_free (runtime_config->domain->private_bin_path);
+       runtime_config->domain->private_bin_path = get_attribute_value (attribute_names, attribute_values, "privatePath");
+       if (runtime_config->domain->private_bin_path && !runtime_config->domain->private_bin_path [0]) {
+               g_free (runtime_config->domain->private_bin_path);
+               runtime_config->domain->private_bin_path = NULL;
+               return;
+       }
+}
+
+static void
+end_element (GMarkupParseContext *context,
+            const gchar         *element_name,
+            gpointer             user_data,
+            GError             **error)
+{
+       RuntimeConfig *runtime_config = user_data;
+       if (strcmp (element_name, "runtime") == 0)
+               runtime_config->runtime_count--;
+       else if (strcmp (element_name, "assemblyBinding") == 0)
+               runtime_config->assemblybinding_count--;
+}
+
+static const GMarkupParser
+mono_parser = {
+       start_element,
+       end_element,
+       NULL,
+       NULL,
+       NULL
+};
+
+static void
+mono_set_private_bin_path_from_config (MonoDomain *domain)
+{
+       gchar *config_file, *text;
+       gsize len;
+       struct stat sbuf;
+       GMarkupParseContext *context;
+       RuntimeConfig runtime_config;
+       
+       if (!domain || !domain->setup || !domain->setup->configuration_file)
+               return;
+
+       config_file = mono_string_to_utf8 (domain->setup->configuration_file);
+       if (stat (config_file, &sbuf) != 0) {
+               g_free (config_file);
+               return;
+       }
+
+       if (!g_file_get_contents (config_file, &text, &len, NULL)) {
+               g_free (config_file);
+               return;
+       }
+       g_free (config_file);
+
+       runtime_config.runtime_count = 0;
+       runtime_config.assemblybinding_count = 0;
+       runtime_config.domain = domain;
+       
+       context = g_markup_parse_context_new (&mono_parser, 0, &runtime_config, NULL);
+       if (g_markup_parse_context_parse (context, text, len, NULL))
+               g_markup_parse_context_end_parse (context, NULL);
+       g_markup_parse_context_free (context);
+       g_free (text);
+}
+
 MonoAppDomain *
 ves_icall_System_AppDomain_createDomain (MonoString *friendly_name, MonoAppDomainSetup *setup)
 {
@@ -503,6 +650,8 @@ ves_icall_System_AppDomain_createDomain (MonoString *friendly_name, MonoAppDomai
        data->domain = ad;
        data->setup = setup;
        data->friendly_name = mono_string_to_utf8 (friendly_name);
+       // FIXME: The ctor runs in the current domain
+       // FIXME: Initialize null_reference_ex and stack_overflow_ex
        data->out_of_memory_ex = mono_exception_from_name_domain (data, mono_defaults.corlib, "System", "OutOfMemoryException");
 
        if (!setup->application_base) {
@@ -512,6 +661,8 @@ ves_icall_System_AppDomain_createDomain (MonoString *friendly_name, MonoAppDomai
                        MONO_OBJECT_SETREF (setup, application_base, mono_string_new_utf16 (data, mono_string_chars (root->setup->application_base), mono_string_length (root->setup->application_base)));
        }
 
+       mono_set_private_bin_path_from_config (data);
+       
        mono_context_init (data);
 
        add_assemblies_to_domain (data, mono_defaults.corlib->assembly, NULL);
@@ -527,42 +678,45 @@ ves_icall_System_AppDomain_GetAssemblies (MonoAppDomain *ad, MonoBoolean refonly
        static MonoClass *System_Reflection_Assembly;
        MonoArray *res;
        GSList *tmp;
-       int i, count;
-       
+       int i;
+       GPtrArray *assemblies;
+
        MONO_ARCH_SAVE_REGS;
 
        if (!System_Reflection_Assembly)
                System_Reflection_Assembly = mono_class_from_name (
                        mono_defaults.corlib, "System.Reflection", "Assembly");
 
-       count = 0;
+       /* 
+        * Make a copy of the list of assemblies because we can't hold the assemblies
+        * lock while creating objects etc.
+        */
+       assemblies = g_ptr_array_new ();
        /* Need to skip internal assembly builders created by remoting */
        mono_domain_assemblies_lock (domain);
-       for (tmp = domain->domain_assemblies; tmp; tmp = tmp->next) {
-               ass = tmp->data;
-               if (refonly && !ass->ref_only)
-                       continue;
-               if (!ass->corlib_internal)
-                       count++;
-       }
-       res = mono_array_new (domain, System_Reflection_Assembly, count);
-       i = 0;
        for (tmp = domain->domain_assemblies; tmp; tmp = tmp->next) {
                ass = tmp->data;
                if (refonly && !ass->ref_only)
                        continue;
                if (ass->corlib_internal)
                        continue;
-               mono_array_setref (res, i, mono_assembly_get_object (domain, ass));
-               ++i;
+               g_ptr_array_add (assemblies, ass);
        }
        mono_domain_assemblies_unlock (domain);
 
+       res = mono_array_new (domain, System_Reflection_Assembly, assemblies->len);
+       for (i = 0; i < assemblies->len; ++i) {
+               ass = g_ptr_array_index (assemblies, i);
+               mono_array_setref (res, i, mono_assembly_get_object (domain, ass));
+       }
+
+       g_ptr_array_free (assemblies, TRUE);
+
        return res;
 }
 
-static MonoReflectionAssembly *
-try_assembly_resolve (MonoDomain *domain, MonoString *fname, gboolean refonly)
+MonoReflectionAssembly *
+mono_try_assembly_resolve (MonoDomain *domain, MonoString *fname, gboolean refonly)
 {
        MonoClass *klass;
        MonoMethod *method;
@@ -598,7 +752,7 @@ mono_domain_assembly_postload_search (MonoAssemblyName *aname,
        aname_str = mono_stringify_assembly_name (aname);
 
        /* FIXME: We invoke managed code here, so there is a potential for deadlocks */
-       assembly = try_assembly_resolve (domain, mono_string_new (domain, aname_str), refonly);
+       assembly = mono_try_assembly_resolve (domain, mono_string_new (domain, aname_str), refonly);
 
        g_free (aname_str);
 
@@ -695,32 +849,58 @@ mono_domain_fire_assembly_load (MonoAssembly *assembly, gpointer user_data)
        mono_runtime_invoke (assembly_load_method, domain->domain, params, NULL);
 }
 
+/*
+ * LOCKING: Acquires the domain assemblies lock.
+ */
 static void
 set_domain_search_path (MonoDomain *domain)
 {
        MonoAppDomainSetup *setup;
        gchar **tmp;
-       gchar *utf8;
+       gchar *search_path = NULL;
        gint i;
        gint npaths = 0;
        gchar **pvt_split = NULL;
        GError *error = NULL;
        gint appbaselen = -1;
 
-       if ((domain->search_path != NULL) && !domain->setup->path_changed)
+       /* 
+        * We use the low-level domain assemblies lock, since this is called from
+        * assembly loads hooks, which means this thread might hold the loader lock.
+        */
+       mono_domain_assemblies_lock (domain);
+
+       if ((domain->search_path != NULL) && !domain->setup->path_changed) {
+               mono_domain_assemblies_unlock (domain);
                return;
-       if (!domain->setup)
+       }
+       if (!domain->setup) {
+               mono_domain_assemblies_unlock (domain);
                return;
+       }
 
        setup = domain->setup;
-       if (!setup->application_base)
+       if (!setup->application_base) {
+               mono_domain_assemblies_unlock (domain);
                return; /* Must set application base to get private path working */
+       }
 
        npaths++;
-       if (setup->private_bin_path) {
-               gint slen;
-               utf8 = mono_string_to_utf8 (setup->private_bin_path);
-
+       
+       if (setup->private_bin_path)
+               search_path = mono_string_to_utf8 (setup->private_bin_path);
+       
+       if (domain->private_bin_path) {
+               if (search_path == NULL)
+                       search_path = domain->private_bin_path;
+               else {
+                       gchar *tmp2 = search_path;
+                       search_path = g_strjoin (";", search_path, domain->private_bin_path, NULL);
+                       g_free (tmp2);
+               }
+       }
+       
+       if (search_path) {
                /*
                 * As per MSDN documentation, AppDomainSetup.PrivateBinPath contains a list of
                 * directories relative to ApplicationBase separated by semicolons (see
@@ -731,13 +911,18 @@ set_domain_search_path (MonoDomain *domain)
                 *
                 * The issue was reported in bug #81446
                 */
-               slen = strlen (utf8);
+
+#ifndef PLATFORM_WIN32
+               gint slen;
+
+               slen = strlen (search_path);
                for (i = 0; i < slen; i++)
-                       if (utf8 [i] == ':')
-                               utf8 [i] = ';';
+                       if (search_path [i] == ':')
+                               search_path [i] = ';';
+#endif
                
-               pvt_split = g_strsplit (utf8, ";", 1000);
-               g_free (utf8);
+               pvt_split = g_strsplit (search_path, ";", 1000);
+               g_free (search_path);
                for (tmp = pvt_split; *tmp; tmp++, npaths++);
        }
 
@@ -751,6 +936,7 @@ set_domain_search_path (MonoDomain *domain)
                 * domain->search_path = g_malloc (sizeof (char *));
                 * domain->search_path [0] = NULL;
                */
+               mono_domain_assemblies_unlock (domain);
                return;
        }
 
@@ -824,6 +1010,8 @@ set_domain_search_path (MonoDomain *domain)
        domain->setup->path_changed = FALSE;
 
        g_strfreev (pvt_split);
+
+       mono_domain_assemblies_unlock (domain);
 }
 
 static gboolean
@@ -947,10 +1135,18 @@ ensure_directory_exists (const char *filename)
        char *p;
        gchar *dir = g_path_get_dirname (filename);
        int retval;
+       struct stat sbuf;
        
-       if (!dir || !dir [0])
+       if (!dir || !dir [0]) {
+               g_free (dir);
                return FALSE;
-
+       }
+       
+       if (stat (dir, &sbuf) == 0 && S_ISDIR (sbuf.st_mode)) {
+               g_free (dir);
+               return TRUE;
+       }
+       
        p = dir;
        while (*p == '/')
                p++;
@@ -974,15 +1170,63 @@ ensure_directory_exists (const char *filename)
 #endif
 }
 
-static char *
-make_shadow_copy (const char *filename)
+static gboolean
+private_file_needs_copying (const char *src, struct stat *sbuf_src, char *dest)
+{
+       struct stat sbuf_dest;
+       
+       if (stat (src, sbuf_src) == -1 || stat (dest, &sbuf_dest) == -1)
+               return TRUE;
+
+       if (sbuf_src->st_mode == sbuf_dest.st_mode &&
+           sbuf_src->st_size == sbuf_dest.st_size &&
+           sbuf_src->st_mtime == sbuf_dest.st_mtime)
+               return FALSE;
+
+       return TRUE;
+}
+
+char *
+mono_make_shadow_copy (const char *filename)
 {
        gchar *sibling_source, *sibling_target;
        gint sibling_source_len, sibling_target_len;
        guint16 *orig, *dest;
        char *shadow;
        gboolean copy_result;
+       gboolean is_private = FALSE;
+       gboolean do_copy = FALSE;
        MonoException *exc;
+       gchar **path;
+       struct stat src_sbuf;
+       struct utimbuf utbuf;
+       char *dir_name = g_path_get_dirname (filename);
+       MonoDomain *domain = mono_domain_get ();
+       set_domain_search_path (domain);
+
+       if (!domain->search_path) {
+               g_free (dir_name);
+               return (char*) filename;
+       }
+       
+       for (path = domain->search_path; *path; path++) {
+               if (**path == '\0') {
+                       is_private = TRUE;
+                       continue;
+               }
+               
+               if (!is_private)
+                       continue;
+
+               if (strstr (dir_name, *path) == dir_name) {
+                       do_copy = TRUE;
+                       break;
+               }
+       }
+       g_free (dir_name);
+
+       if (!do_copy)
+               return (char*) filename;
        
        shadow = get_shadow_assembly_location (filename);
        if (ensure_directory_exists (shadow) == FALSE) {
@@ -990,6 +1234,9 @@ make_shadow_copy (const char *filename)
                mono_raise_exception (exc);
        }       
 
+       if (!private_file_needs_copying (filename, &src_sbuf, shadow))
+               return (char*) shadow;
+
        orig = g_utf8_to_utf16 (filename, strlen (filename), NULL, NULL, NULL);
        dest = g_utf8_to_utf16 (shadow, strlen (shadow), NULL, NULL, NULL);
        DeleteFile (dest);
@@ -1021,29 +1268,47 @@ make_shadow_copy (const char *filename)
                exc = mono_get_exception_execution_engine ("Failed to create shadow copy of sibling data (CopyFile).");
                mono_raise_exception (exc);
        }
+
+       utbuf.actime = src_sbuf.st_atime;
+       utbuf.modtime = src_sbuf.st_mtime;
+       utime (shadow, &utbuf);
        
        return shadow;
 }
 
+
+MonoDomain *
+mono_domain_from_appdomain (MonoAppDomain *appdomain)
+{
+       if (appdomain == NULL)
+               return NULL;
+       
+       return appdomain->data;
+}
+
 static gboolean
 try_load_from (MonoAssembly **assembly, const gchar *path1, const gchar *path2,
                                        const gchar *path3, const gchar *path4,
                                        gboolean refonly, gboolean is_private)
 {
-       
        gchar *fullpath;
-
+       gboolean found = FALSE;
+       
        *assembly = NULL;
        fullpath = g_build_filename (path1, path2, path3, path4, NULL);
-       if (g_file_test (fullpath, G_FILE_TEST_IS_REGULAR)) {
-               if (is_private) {
-                       char *new_path = make_shadow_copy (fullpath);
+
+       if (IS_PORTABILITY_SET) {
+               gchar *new_fullpath = mono_portability_find_file (fullpath, TRUE);
+               if (new_fullpath) {
                        g_free (fullpath);
-                       fullpath = new_path;
+                       fullpath = new_fullpath;
+                       found = TRUE;
                }
-
+       } else
+               found = g_file_test (fullpath, G_FILE_TEST_IS_REGULAR);
+       
+       if (found)
                *assembly = mono_assembly_open_full (fullpath, NULL, refonly);
-       }
 
        g_free (fullpath);
        return (*assembly != NULL);
@@ -1103,6 +1368,8 @@ real_load (gchar **search_path, const gchar *culture, const gchar *name, gboolea
 /*
  * Try loading the assembly from ApplicationBase and PrivateBinPath 
  * and then from assemblies_path if any.
+ * LOCKING: This is called from the assembly loading code, which means the caller
+ * might hold the loader lock. Thus, this function must not acquire the domain lock.
  */
 static MonoAssembly *
 mono_domain_assembly_preload (MonoAssemblyName *aname,
@@ -1169,7 +1436,7 @@ ves_icall_System_Reflection_Assembly_LoadFrom (MonoString *fname, MonoBoolean re
        }
                
        name = filename = mono_string_to_utf8 (fname);
-
+       
        ass = mono_assembly_open_full (filename, &status, refOnly);
        
        if (!ass){
@@ -1250,13 +1517,20 @@ ves_icall_System_AppDomain_LoadAssembly (MonoAppDomain *ad,  MonoString *assRef,
                mono_raise_exception (exc);
        }
 
-       ass = mono_assembly_load_full (&aname, NULL, &status, refOnly);
+       ass = mono_assembly_load_full_nosearch (&aname, NULL, &status, refOnly);
        mono_assembly_name_free (&aname);
 
-       if (!ass && (refass = try_assembly_resolve (domain, assRef, refOnly)) == NULL){
-               /* FIXME: it doesn't make much sense since we really don't have a filename ... */
-               MonoException *exc = mono_get_exception_file_not_found2 (NULL, assRef);
-               mono_raise_exception (exc);
+       if (!ass) {
+               /* MS.NET doesn't seem to call the assembly resolve handler for refonly assemblies */
+               if (!refOnly)
+                       refass = mono_try_assembly_resolve (domain, assRef, refOnly);
+               else
+                       refass = NULL;
+               if (!refass) {
+                       /* FIXME: it doesn't make much sense since we really don't have a filename ... */
+                       MonoException *exc = mono_get_exception_file_not_found2 (NULL, assRef);
+                       mono_raise_exception (exc);
+               }
        }
 
        if (refass == NULL)
@@ -1305,26 +1579,17 @@ ves_icall_System_AppDomain_InternalIsFinalizingForUnload (gint32 domain_id)
 }
 
 gint32
-ves_icall_System_AppDomain_ExecuteAssembly (MonoAppDomain *ad, MonoString *file, 
-                                           MonoObject *evidence, MonoArray *args)
+ves_icall_System_AppDomain_ExecuteAssembly (MonoAppDomain *ad, 
+                                                                                       MonoReflectionAssembly *refass, MonoArray *args)
 {
-       MonoAssembly *assembly;
        MonoImage *image;
        MonoMethod *method;
-       char *filename;
-       gint32 res;
-       MonoReflectionAssembly *refass;
 
        MONO_ARCH_SAVE_REGS;
 
-       filename = mono_string_to_utf8 (file);
-       assembly = mono_assembly_open (filename, NULL);
-       g_free (filename);
-
-       if (!assembly)
-               mono_raise_exception (mono_get_exception_file_not_found2 (NULL, file));
-
-       image = assembly->image;
+       g_assert (refass);
+       image = refass->assembly->image;
+       g_assert (image);
 
        method = mono_get_method (image, mono_image_get_entry_point (image), NULL);
 
@@ -1334,12 +1599,7 @@ ves_icall_System_AppDomain_ExecuteAssembly (MonoAppDomain *ad, MonoString *file,
        if (!args)
                args = (MonoArray *) mono_array_new (ad->data, mono_defaults.string_class, 0);
 
-       refass = mono_assembly_get_object (ad->data, assembly);
-       MONO_OBJECT_SETREF (refass, evidence, evidence);
-
-       res = mono_runtime_exec_main (method, (MonoArray *)args, NULL);
-
-       return res;
+       return mono_runtime_exec_main (method, (MonoArray *)args, NULL);
 }
 
 gint32 
@@ -1489,13 +1749,13 @@ unload_thread_main (void *arg)
         * 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)) {
+       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;
        }
 
        /* Finalize all finalizable objects in the doomed appdomain */
-       if (!mono_domain_finalize (domain, 10000)) {
+       if (!mono_domain_finalize (domain, -1)) {
                data->failure_reason = g_strdup_printf ("Finalization of domain %s timed out.", domain->friendly_name);
                return 1;
        }