mono/metadata/appdomain.c

   1 /*
   2  * appdomain.c: AppDomain functions
   3  *
   4  * Authors:
   5  *      Dietmar Maurer (dietmar@ximian.com)
   6  *      Patrik Torstensson
   7  *      Gonzalo Paniagua Javier (gonzalo@ximian.com)
   8  *
   9  * (c) 2001-2003 Ximian, Inc. (http://www.ximian.com)
  10  */
  11
  12 #include <config.h>
  13 #include <glib.h>
  14 #include <string.h>
  15
  16 #include <mono/os/gc_wrapper.h>
  17
  18 #include <mono/metadata/object.h>
  19 #include <mono/metadata/domain-internals.h>
  20 #include "mono/metadata/metadata-internals.h"
  21 #include <mono/metadata/assembly.h>
  22 #include <mono/metadata/exception.h>
  23 #include <mono/metadata/threads.h>
  24 #include <mono/metadata/socket-io.h>
  25 #include <mono/metadata/tabledefs.h>
  26 #include <mono/metadata/gc-internal.h>
  27 #include <mono/metadata/mono-gc.h>
  28 #include <mono/metadata/marshal.h>
  29 #include <mono/metadata/monitor.h>
  30 #include <mono/metadata/threadpool.h>
  31 #include <mono/utils/mono-uri.h>
  32
  33 #define MONO_CORLIB_VERSION 32
  34
  35 CRITICAL_SECTION mono_delegate_section;
  36
  37 static gunichar2 process_guid [36];
  38 static gboolean process_guid_set = FALSE;
  39
  40 static gboolean shutting_down = FALSE;
  41
  42 static MonoAssembly *
  43 mono_domain_assembly_preload (MonoAssemblyName *aname,
  44                               gchar **assemblies_path,
  45                               gpointer user_data);
  46
  47 static MonoAssembly *
  48 mono_domain_assembly_search (MonoAssemblyName *aname,
  49                                                          gpointer user_data);
  50
  51 static void
  52 mono_domain_fire_assembly_load (MonoAssembly *assembly, gpointer user_data);
  53
  54 static void
  55 add_assemblies_to_domain (MonoDomain *domain, MonoAssembly *ass, GHashTable *hash);
  56
  57 static void
  58 mono_domain_unload (MonoDomain *domain);
  59
  60 /**
  61  * mono_runtime_init:
  62  * @domain: domain returned by mono_init ()
  63  *
  64  * Initialize the core AppDomain: this function will run also some
  65  * IL initialization code, so it needs the execution engine to be fully
  66  * operational.
  67  *
  68  * AppDomain.SetupInformation is set up in mono_runtime_exec_main, where
  69  * we know the entry_assembly.
  70  *
  71  */
  72 void
  73 mono_runtime_init (MonoDomain *domain, MonoThreadStartCB start_cb,
  74                    MonoThreadAttachCB attach_cb)
  75 {
  76         MonoAppDomainSetup *setup;
  77         MonoAppDomain *ad;
  78         MonoClass *class;
  79         MonoString *arg;
  80
  81         MONO_GC_PRE_INIT ();
  82         mono_monitor_init ();
  83         mono_thread_pool_init ();
  84         mono_marshal_init ();
  85
  86         mono_install_assembly_preload_hook (mono_domain_assembly_preload, NULL);
  87         mono_install_assembly_search_hook (mono_domain_assembly_search, NULL);
  88         mono_install_assembly_load_hook (mono_domain_fire_assembly_load, NULL);
  89         mono_install_lookup_dynamic_token (mono_reflection_lookup_dynamic_token);
  90
  91         mono_thread_init (start_cb, attach_cb);
  92
  93         class = mono_class_from_name (mono_defaults.corlib, "System", "AppDomainSetup");
  94         setup = (MonoAppDomainSetup *) mono_object_new (domain, class);
  95
  96         class = mono_class_from_name (mono_defaults.corlib, "System", "AppDomain");
  97         ad = (MonoAppDomain *) mono_object_new (domain, class);
  98         ad->data = domain;
  99         domain->domain = ad;
 100         domain->setup = setup;
 101
 102         InitializeCriticalSection (&mono_delegate_section);
 103
 104         mono_context_init (domain);
 105         mono_context_set (domain->default_context);
 106
 107         mono_type_initialization_init ();
 108
 109
 110         /*
 111          * Create an instance early since we can't do it when there is no memory.
 112          */
 113         arg = mono_string_new (domain, "Out of memory");
 114         domain->out_of_memory_ex = mono_exception_from_name_two_strings (mono_defaults.corlib, "System", "OutOfMemoryException", arg, NULL);
 115
 116         /*
 117          * These two are needed because the signal handlers might be executing on
 118          * an alternate stack, and Boehm GC can't handle that.
 119          */
 120         arg = mono_string_new (domain, "A null value was found where an object instance was required");
 121         domain->null_reference_ex = mono_exception_from_name_two_strings (mono_defaults.corlib, "System", "NullReferenceException", arg, NULL);
 122         arg = mono_string_new (domain, "The requested operation caused a stack overflow.");
 123         domain->stack_overflow_ex = mono_exception_from_name_two_strings (mono_defaults.corlib, "System", "StackOverflowException", arg, NULL);
 124
 125         /* GC init has to happen after thread init */
 126         mono_gc_init ();
 127
 128         mono_network_init ();
 129
 130         /* mscorlib is loaded before we install the load hook */
 131         mono_domain_fire_assembly_load (mono_defaults.corlib->assembly, NULL);
 132
 133         return;
 134 }
 135
 136 static int
 137 mono_get_corlib_version (void)
 138 {
 139         MonoClass *klass;
 140         MonoClassField *field;
 141         MonoObject *value;
 142
 143         klass = mono_class_from_name (mono_defaults.corlib, "System", "Environment");
 144         mono_class_init (klass);
 145         field = mono_class_get_field_from_name (klass, "mono_corlib_version");
 146         if (!field)
 147                 return -1;
 148         if (! (field->type->attrs & FIELD_ATTRIBUTE_STATIC))
 149                 return -1;
 150         value = mono_field_get_value_object (mono_domain_get (), field, NULL);
 151         return *(gint32*)((gchar*)value + sizeof (MonoObject));
 152 }
 153
 154 const char*
 155 mono_check_corlib_version (void)
 156 {
 157         int version = mono_get_corlib_version ();
 158         if (version != MONO_CORLIB_VERSION)
 159                 return g_strdup_printf ("expected corlib version %d, found %d.", MONO_CORLIB_VERSION, version);
 160         else
 161                 return NULL;
 162 }
 163
 164 void
 165 mono_context_init (MonoDomain *domain)
 166 {
 167         MonoClass *class;
 168         MonoAppContext *context;
 169
 170         class = mono_class_from_name (mono_defaults.corlib, "System.Runtime.Remoting.Contexts", "Context");
 171         context = (MonoAppContext *) mono_object_new (domain, class);
 172         context->domain_id = domain->domain_id;
 173         context->context_id = 0;
 174         domain->default_context = context;
 175 }
 176
 177 /* This must not be called while there are still running threads executing
 178  * managed code.
 179  */
 180 void
 181 mono_runtime_cleanup (MonoDomain *domain)
 182 {
 183         shutting_down = TRUE;
 184
 185         /* This ends up calling any pending pending (for at most 2 seconds) */
 186         mono_gc_cleanup ();
 187
 188         mono_network_cleanup ();
 189 }
 190
 191 static MonoDomainFunc quit_function = NULL;
 192
 193 void
 194 mono_install_runtime_cleanup (MonoDomainFunc func)
 195 {
 196         quit_function = func;
 197 }
 198
 199 void
 200 mono_runtime_quit ()
 201 {
 202         if (quit_function != NULL)
 203                 quit_function (mono_get_root_domain (), NULL);
 204 }
 205
 206 gboolean
 207 mono_runtime_is_shutting_down (void)
 208 {
 209         return shutting_down;
 210 }
 211
 212 gboolean
 213 mono_domain_has_type_resolve (MonoDomain *domain)
 214 {
 215         static MonoClassField *field = NULL;
 216         MonoObject *o;
 217
 218         if (field == NULL) {
 219                 field = mono_class_get_field_from_name (mono_defaults.appdomain_class, "TypeResolve");
 220                 g_assert (field);
 221         }
 222
 223         mono_field_get_value ((MonoObject*)(domain->domain), field, &o);
 224         return o != NULL;
 225 }
 226
 227 MonoReflectionAssembly *
 228 mono_domain_try_type_resolve (MonoDomain *domain, char *name, MonoObject *tb)
 229 {
 230         MonoClass *klass;
 231         void *params [1];
 232         static MonoMethod *method = NULL;
 233
 234         g_assert (domain != NULL && ((name != NULL) || (tb != NULL)));
 235
 236         if (method == NULL) {
 237                 klass = domain->domain->mbr.obj.vtable->klass;
 238                 g_assert (klass);
 239
 240                 method = mono_class_get_method_from_name (klass, "DoTypeResolve", -1);
 241                 if (method == NULL) {
 242                         g_warning ("Method AppDomain.DoTypeResolve not found.\n");
 243                         return NULL;
 244                 }
 245         }
 246
 247         if (name)
 248                 *params = (MonoObject*)mono_string_new (mono_domain_get (), name);
 249         else
 250                 *params = tb;
 251         return (MonoReflectionAssembly *) mono_runtime_invoke (method, domain->domain, params, NULL);
 252 }
 253
 254 /**
 255  * mono_domain_owns_vtable_slot:
 256  *
 257  *   Returns whenever VTABLE_SLOT is inside a vtable which belongs to DOMAIN.
 258  */
 259 gboolean
 260 mono_domain_owns_vtable_slot (MonoDomain *domain, gpointer vtable_slot)
 261 {
 262         gboolean res;
 263
 264         mono_domain_lock (domain);
 265         res = mono_mempool_contains_addr (domain->mp, vtable_slot);
 266         mono_domain_unlock (domain);
 267         return res;
 268 }
 269
 270 /**
 271  * mono_domain_set:
 272  * @domain: domain
 273  * @force: force setting.
 274  *
 275  *   Set the current appdomain to @domain. If @force is set, set it even
 276  * if it is being unloaded.
 277  *
 278  * Returns:
 279  *   TRUE on success;
 280  *   FALSE if the domain is unloaded
 281  */
 282 gboolean
 283 mono_domain_set (MonoDomain *domain, gboolean force)
 284 {
 285         if (!force && domain->state == MONO_APPDOMAIN_UNLOADED)
 286                 return FALSE;
 287
 288         mono_domain_set_internal (domain);
 289
 290         return TRUE;
 291 }
 292
 293 MonoObject *
 294 ves_icall_System_AppDomain_GetData (MonoAppDomain *ad, MonoString *name)
 295 {
 296         MonoDomain *add = ad->data;
 297         MonoObject *o;
 298         char *str;
 299
 300         MONO_ARCH_SAVE_REGS;
 301
 302         g_assert (ad != NULL);
 303
 304         if (name == NULL)
 305                 mono_raise_exception (mono_get_exception_argument_null ("name"));
 306
 307         str = mono_string_to_utf8 (name);
 308
 309         mono_domain_lock (add);
 310
 311         if (!strcmp (str, "APPBASE"))
 312                 o = (MonoObject *)add->setup->application_base;
 313         else if (!strcmp (str, "APP_CONFIG_FILE"))
 314                 o = (MonoObject *)add->setup->configuration_file;
 315         else if (!strcmp (str, "DYNAMIC_BASE"))
 316                 o = (MonoObject *)add->setup->dynamic_base;
 317         else if (!strcmp (str, "APP_NAME"))
 318                 o = (MonoObject *)add->setup->application_name;
 319         else if (!strcmp (str, "CACHE_BASE"))
 320                 o = (MonoObject *)add->setup->cache_path;
 321         else if (!strcmp (str, "PRIVATE_BINPATH"))
 322                 o = (MonoObject *)add->setup->private_bin_path;
 323         else if (!strcmp (str, "BINPATH_PROBE_ONLY"))
 324                 o = (MonoObject *)add->setup->private_bin_path_probe;
 325         else if (!strcmp (str, "SHADOW_COPY_DIRS"))
 326                 o = (MonoObject *)add->setup->shadow_copy_directories;
 327         else if (!strcmp (str, "FORCE_CACHE_INSTALL"))
 328                 o = (MonoObject *)add->setup->shadow_copy_files;
 329         else
 330                 o = mono_g_hash_table_lookup (add->env, name);
 331
 332         mono_domain_unlock (add);
 333         g_free (str);
 334
 335         if (!o)
 336                 return NULL;
 337
 338         return o;
 339 }
 340
 341 void
 342 ves_icall_System_AppDomain_SetData (MonoAppDomain *ad, MonoString *name, MonoObject *data)
 343 {
 344         MonoDomain *add = ad->data;
 345
 346         MONO_ARCH_SAVE_REGS;
 347
 348         g_assert (ad != NULL);
 349
 350         if (name == NULL)
 351                 mono_raise_exception (mono_get_exception_argument_null ("name"));
 352
 353         mono_domain_lock (add);
 354
 355         mono_g_hash_table_insert (add->env, name, data);
 356
 357         mono_domain_unlock (add);
 358 }
 359
 360 MonoAppDomainSetup *
 361 ves_icall_System_AppDomain_getSetup (MonoAppDomain *ad)
 362 {
 363         MONO_ARCH_SAVE_REGS;
 364
 365         g_assert (ad != NULL);
 366         g_assert (ad->data != NULL);
 367
 368         return ad->data->setup;
 369 }
 370
 371 MonoString *
 372 ves_icall_System_AppDomain_getFriendlyName (MonoAppDomain *ad)
 373 {
 374         MONO_ARCH_SAVE_REGS;
 375
 376         g_assert (ad != NULL);
 377         g_assert (ad->data != NULL);
 378
 379         return mono_string_new (ad->data, ad->data->friendly_name);
 380 }
 381
 382 MonoAppDomain *
 383 ves_icall_System_AppDomain_getCurDomain ()
 384 {
 385         MonoDomain *add = mono_domain_get ();
 386
 387         MONO_ARCH_SAVE_REGS;
 388
 389         return add->domain;
 390 }
 391
 392 MonoAppDomain *
 393 ves_icall_System_AppDomain_getRootDomain ()
 394 {
 395         MonoDomain *root = mono_get_root_domain ();
 396
 397         MONO_ARCH_SAVE_REGS;
 398
 399         return root->domain;
 400 }
 401
 402 MonoAppDomain *
 403 ves_icall_System_AppDomain_createDomain (MonoString *friendly_name, MonoAppDomainSetup *setup)
 404 {
 405         MonoDomain *domain = mono_domain_get ();
 406         MonoClass *adclass;
 407         MonoAppDomain *ad;
 408         MonoDomain *data;
 409         GSList *tmp;
 410
 411         MONO_ARCH_SAVE_REGS;
 412
 413         adclass = mono_class_from_name (mono_defaults.corlib, "System", "AppDomain");
 414
 415         /* FIXME: pin all those objects */
 416         data = mono_domain_create();
 417
 418         ad = (MonoAppDomain *) mono_object_new (data, adclass);
 419         ad->data = data;
 420         data->domain = ad;
 421         data->setup = setup;
 422         data->friendly_name = mono_string_to_utf8 (friendly_name);
 423         data->out_of_memory_ex = mono_exception_from_name_domain (data, mono_defaults.corlib, "System", "OutOfMemoryException");
 424
 425         if (!setup->application_base) {
 426                 /* Inherit from the root domain since MS.NET does this */
 427                 MonoDomain *root = mono_get_root_domain ();
 428                 setup->application_base = mono_string_new_utf16 (data, mono_string_chars (root->setup->application_base), mono_string_length (root->setup->application_base));
 429         }
 430
 431         mono_context_init (data);
 432
 433         /* The new appdomain should have all assemblies loaded */
 434         mono_domain_lock (domain);
 435         /*g_print ("copy assemblies from domain %p (%s)\n", domain, domain->friendly_name);*/
 436         for (tmp = domain->domain_assemblies; tmp; tmp = tmp->next)
 437                 add_assemblies_to_domain (data, tmp->data, NULL);
 438         mono_domain_unlock (domain);
 439
 440         return ad;
 441 }
 442
 443 MonoArray *
 444 ves_icall_System_AppDomain_GetAssemblies (MonoAppDomain *ad)
 445 {
 446         MonoDomain *domain = ad->data;
 447         MonoAssembly* ass;
 448         static MonoClass *System_Reflection_Assembly;
 449         MonoArray *res;
 450         GSList *tmp;
 451         int i, count;
 452
 453         MONO_ARCH_SAVE_REGS;
 454
 455         if (!System_Reflection_Assembly)
 456                 System_Reflection_Assembly = mono_class_from_name (
 457                         mono_defaults.corlib, "System.Reflection", "Assembly");
 458
 459         count = 0;
 460         /* Need to skip internal assembly builders created by remoting */
 461         mono_domain_lock (domain);
 462         for (tmp = domain->domain_assemblies; tmp; tmp = tmp->next) {
 463                 ass = tmp->data;
 464                 if (!ass->corlib_internal)
 465                         count++;
 466         }
 467         res = mono_array_new (domain, System_Reflection_Assembly, count);
 468         i = 0;
 469         for (tmp = domain->domain_assemblies; tmp; tmp = tmp->next) {
 470                 ass = tmp->data;
 471                 if (ass->corlib_internal)
 472                         continue;
 473                 mono_array_set (res, gpointer, i, mono_assembly_get_object (domain, ass));
 474                 ++i;
 475         }
 476         mono_domain_unlock (domain);
 477
 478         return res;
 479 }
 480
 481 static MonoReflectionAssembly *
 482 try_assembly_resolve (MonoDomain *domain, MonoString *fname)
 483 {
 484         MonoClass *klass;
 485         MonoMethod *method;
 486         void *params [1];
 487
 488         g_assert (domain != NULL && fname != NULL);
 489
 490         klass = domain->domain->mbr.obj.vtable->klass;
 491         g_assert (klass);
 492
 493         method = mono_class_get_method_from_name (klass, "DoAssemblyResolve", -1);
 494         if (method == NULL) {
 495                 g_warning ("Method AppDomain.DoAssemblyResolve not found.\n");
 496                 return NULL;
 497         }
 498
 499         *params = fname;
 500         return (MonoReflectionAssembly *) mono_runtime_invoke (method, domain->domain, params, NULL);
 501 }
 502
 503 /*
 504  * LOCKING: assumes domain is already locked.
 505  */
 506 static void
 507 add_assemblies_to_domain (MonoDomain *domain, MonoAssembly *ass, GHashTable *ht)
 508 {
 509         gint i;
 510         GSList *tmp;
 511         gboolean destroy_ht = FALSE;
 512
 513         if (!ass->aname.name)
 514                 return;
 515
 516         if (!ht) {
 517                 ht = g_hash_table_new (mono_aligned_addr_hash, NULL);
 518                 destroy_ht = TRUE;
 519         }
 520
 521         /* FIXME: handle lazy loaded assemblies */
 522         for (tmp = domain->domain_assemblies; tmp; tmp = tmp->next) {
 523                 g_hash_table_insert (ht, tmp->data, tmp->data);
 524         }
 525         if (!g_hash_table_lookup (ht, ass)) {
 526                 mono_assembly_addref (ass);
 527                 g_hash_table_insert (ht, ass, ass);
 528                 domain->domain_assemblies = g_slist_prepend (domain->domain_assemblies, ass);
 529         }
 530
 531         if (ass->image->references) {
 532                 for (i = 0; ass->image->references [i] != NULL; i++) {
 533                         if (!g_hash_table_lookup (ht, ass->image->references [i])) {
 534                                 add_assemblies_to_domain (domain, ass->image->references [i], ht);
 535                         }
 536                 }
 537         }
 538         if (destroy_ht)
 539                 g_hash_table_destroy (ht);
 540 }
 541
 542 static void
 543 mono_domain_fire_assembly_load (MonoAssembly *assembly, gpointer user_data)
 544 {
 545         MonoDomain *domain = mono_domain_get ();
 546         MonoReflectionAssembly *ref_assembly;
 547         MonoClass *klass;
 548         MonoMethod *method;
 549         void *params [1];
 550
 551         if (!domain->domain)
 552                 /* This can happen during startup */
 553                 return;
 554
 555         klass = domain->domain->mbr.obj.vtable->klass;
 556
 557         method = mono_class_get_method_from_name (klass, "DoAssemblyLoad", -1);
 558         if (method == NULL) {
 559                 g_warning ("Method AppDomain.DoAssemblyLoad not found.\n");
 560                 return;
 561         }
 562
 563         mono_domain_lock (domain);
 564         add_assemblies_to_domain (domain, assembly, NULL);
 565         mono_domain_unlock (domain);
 566
 567         ref_assembly = mono_assembly_get_object (domain, assembly);
 568         g_assert (ref_assembly);
 569
 570         *params = ref_assembly;
 571         mono_runtime_invoke (method, domain->domain, params, NULL);
 572 }
 573
 574 static gchar *
 575 reduce_path (const gchar *dirname)
 576 {
 577         gchar **parts;
 578         gchar *part;
 579         GList *list, *tmp;
 580         GString *result;
 581         gchar *res;
 582         gint i;
 583
 584         parts = g_strsplit (dirname, G_DIR_SEPARATOR_S, 0);
 585         list = NULL;
 586         for (i = 0; (part = parts [i]) != NULL; i++) {
 587                 if (!strcmp (part, "."))
 588                         continue;
 589
 590                 if (!strcmp (part, "..")) {
 591                         if (list && list->next) /* Don't remove root */
 592                                 list = g_list_delete_link (list, list);
 593                 } else {
 594                         list = g_list_prepend (list, part);
 595                 }
 596         }
 597
 598         result = g_string_new ("");
 599         list = g_list_reverse (list);
 600
 601         for (tmp = list; tmp; tmp = tmp->next) {
 602                 gchar *data = (gchar *) tmp->data;
 603
 604                 if (data && *data) {
 605 #ifdef PLATFORM_WIN32
 606                         if (result->len == 0)
 607                                 g_string_append_printf (result, "%s\\", data);
 608                         else if (result->str [result->len - 1] == '\\')
 609                                 g_string_append_printf (result, "%s", data);
 610                         else
 611 #endif
 612                                 g_string_append_printf (result, "%c%s",
 613                                                         G_DIR_SEPARATOR, data);
 614                 }
 615         }
 616
 617         res = result->str;
 618         g_string_free (result, FALSE);
 619         g_list_free (list);
 620         g_strfreev (parts);
 621         return res;
 622 }
 623
 624 static void
 625 set_domain_search_path (MonoDomain *domain)
 626 {
 627         MonoAppDomainSetup *setup;
 628         gchar **tmp;
 629         gchar *utf8;
 630         gint i;
 631         gint npaths = 0;
 632         gchar **pvt_split = NULL;
 633         GError *error = NULL;
 634         gint appbaselen = -1;
 635
 636         if ((domain->search_path != NULL) && !domain->setup->path_changed)
 637                 return;
 638         if (!domain->setup)
 639                 return;
 640
 641         setup = domain->setup;
 642         if (!setup->application_base)
 643                 return; /* Must set application base to get private path working */
 644
 645         npaths++;
 646         if (setup->private_bin_path) {
 647                 utf8 = mono_string_to_utf8 (setup->private_bin_path);
 648                 pvt_split = g_strsplit (utf8, G_SEARCHPATH_SEPARATOR_S, 1000);
 649                 g_free (utf8);
 650                 for (tmp = pvt_split; *tmp; tmp++, npaths++);
 651         }
 652
 653         if (!npaths) {
 654                 if (pvt_split)
 655                         g_strfreev (pvt_split);
 656                 /*
 657                  * Don't do this because the first time is called, the domain
 658                  * setup is not finished.
 659                  *
 660                  * domain->search_path = g_malloc (sizeof (char *));
 661                  * domain->search_path [0] = NULL;
 662                 */
 663                 return;
 664         }
 665
 666         if (domain->search_path)
 667                 g_strfreev (domain->search_path);
 668
 669         domain->search_path = tmp = g_malloc ((npaths + 1) * sizeof (gchar *));
 670         tmp [npaths] = NULL;
 671
 672         *tmp = mono_string_to_utf8 (setup->application_base);
 673
 674         /* FIXME: is this needed? */
 675         if (strncmp (*tmp, "file://", 7) == 0) {
 676                 gchar *file = *tmp;
 677                 gchar *uri = *tmp;
 678                 gchar *tmpuri;
 679
 680                 if (uri [7] != '/')
 681                         uri = g_strdup_printf ("file:///%s", uri + 7);
 682
 683                 tmpuri = uri;
 684                 uri = mono_escape_uri_string (tmpuri);
 685                 *tmp = g_filename_from_uri (uri, NULL, &error);
 686                 g_free (uri);
 687
 688                 if (tmpuri != file)
 689                         g_free (tmpuri);
 690
 691                 if (error != NULL) {
 692                         g_warning ("%s\n", error->message);
 693                         g_error_free (error);
 694                         *tmp = file;
 695                 } else {
 696                         g_free (file);
 697                 }
 698         }
 699
 700         for (i = 1; pvt_split && i < npaths; i++) {
 701                 if (g_path_is_absolute (pvt_split [i - 1])) {
 702                         tmp [i] = g_strdup (pvt_split [i - 1]);
 703                 } else {
 704                         tmp [i] = g_build_filename (tmp [0], pvt_split [i - 1], NULL);
 705                 }
 706
 707                 if (strchr (tmp [i], '.')) {
 708                         gchar *reduced;
 709                         gchar *freeme;
 710
 711                         reduced = reduce_path (tmp [i]);
 712                         if (appbaselen == -1)
 713                                 appbaselen = strlen (tmp [0]);
 714
 715                         if (strncmp (tmp [0], reduced, appbaselen)) {
 716                                 g_free (reduced);
 717                                 g_free (tmp [i]);
 718                                 tmp [i] = g_strdup ("");
 719                                 continue;
 720                         }
 721
 722                         freeme = tmp [i];
 723                         tmp [i] = reduced;
 724                         g_free (freeme);
 725                 }
 726         }
 727
 728         if (setup->private_bin_path_probe != NULL) {
 729                 g_free (tmp [0]);
 730                 tmp [0] = g_strdup ("");
 731         }
 732
 733         domain->setup->path_changed = FALSE;
 734
 735         g_strfreev (pvt_split);
 736 }
 737
 738 static gboolean
 739 try_load_from (MonoAssembly **assembly, const gchar *path1, const gchar *path2,
 740                                         const gchar *path3, const gchar *path4)
 741 {
 742         gchar *fullpath;
 743
 744         *assembly = NULL;
 745         fullpath = g_build_filename (path1, path2, path3, path4, NULL);
 746         if (g_file_test (fullpath, G_FILE_TEST_IS_REGULAR))
 747                 *assembly = mono_assembly_open (fullpath, NULL);
 748
 749         g_free (fullpath);
 750         return (*assembly != NULL);
 751 }
 752
 753 static MonoAssembly *
 754 real_load (gchar **search_path, const gchar *culture, const gchar *name)
 755 {
 756         MonoAssembly *result = NULL;
 757         gchar **path;
 758         gchar *filename;
 759         const gchar *local_culture;
 760         gint len;
 761
 762         if (!culture || *culture == '\0') {
 763                 local_culture = "";
 764         } else {
 765                 local_culture = culture;
 766         }
 767
 768         filename =  g_strconcat (name, ".dll", NULL);
 769         len = strlen (filename);
 770
 771         for (path = search_path; *path; path++) {
 772                 if (**path == '\0')
 773                         continue; /* Ignore empty ApplicationBase */
 774
 775                 /* See test cases in bug #58992 and bug #57710 */
 776                 /* 1st try: [culture]/[name].dll (culture may be empty) */
 777                 strcpy (filename + len - 4, ".dll");
 778                 if (try_load_from (&result, *path, local_culture, "", filename))
 779                         break;
 780
 781                 /* 2nd try: [culture]/[name].exe (culture may be empty) */
 782                 strcpy (filename + len - 4, ".exe");
 783                 if (try_load_from (&result, *path, local_culture, "", filename))
 784                         break;
 785
 786                 /* 3rd try: [culture]/[name]/[name].dll (culture may be empty) */
 787                 strcpy (filename + len - 4, ".dll");
 788                 if (try_load_from (&result, *path, local_culture, name, filename))
 789                         break;
 790
 791                 /* 4th try: [culture]/[name]/[name].exe (culture may be empty) */
 792                 strcpy (filename + len - 4, ".exe");
 793                 if (try_load_from (&result, *path, local_culture, name, filename))
 794                         break;
 795         }
 796
 797         g_free (filename);
 798         return result;
 799 }
 800
 801 /*
 802  * Try loading the assembly from ApplicationBase and PrivateBinPath
 803  * and then from assemblies_path if any.
 804  */
 805 static MonoAssembly *
 806 mono_domain_assembly_preload (MonoAssemblyName *aname,
 807                               gchar **assemblies_path,
 808                               gpointer user_data)
 809 {
 810         MonoDomain *domain = mono_domain_get ();
 811         MonoAssembly *result = NULL;
 812
 813         set_domain_search_path (domain);
 814
 815         if (domain->search_path && domain->search_path [0] != NULL) {
 816                 result = real_load (domain->search_path, aname->culture, aname->name);
 817         }
 818
 819         if (result == NULL && assemblies_path && assemblies_path [0] != NULL) {
 820                 result = real_load (assemblies_path, aname->culture, aname->name);
 821         }
 822
 823         return result;
 824 }
 825
 826 /*
 827  * Check whenever a given assembly was already loaded in the current appdomain.
 828  */
 829 static MonoAssembly *
 830 mono_domain_assembly_search (MonoAssemblyName *aname,
 831                                                          gpointer user_data)
 832 {
 833         MonoDomain *domain = mono_domain_get ();
 834         GSList *tmp;
 835         MonoAssembly *ass;
 836
 837         mono_domain_lock (domain);
 838         for (tmp = domain->domain_assemblies; tmp; tmp = tmp->next) {
 839                 ass = tmp->data;
 840                 /* Dynamic assemblies can't match here in MS.NET */
 841                 if (ass->dynamic || !mono_assembly_names_equal (aname, &ass->aname))
 842                         continue;
 843
 844                 mono_domain_unlock (domain);
 845                 return ass;
 846         }
 847         mono_domain_unlock (domain);
 848
 849         return NULL;
 850 }
 851
 852 MonoReflectionAssembly *
 853 ves_icall_System_Reflection_Assembly_LoadFrom (MonoString *fname)
 854 {
 855         MonoDomain *domain = mono_domain_get ();
 856         char *name, *filename;
 857         MonoImageOpenStatus status = MONO_IMAGE_OK;
 858         MonoAssembly *ass;
 859
 860         MONO_ARCH_SAVE_REGS;
 861
 862         if (fname == NULL) {
 863                 MonoException *exc = mono_get_exception_argument_null ("assemblyFile");
 864                 mono_raise_exception (exc);
 865         }
 866
 867         name = filename = mono_string_to_utf8 (fname);
 868
 869         ass = mono_assembly_open (filename, &status);
 870
 871         g_free (name);
 872
 873         if (!ass){
 874                 MonoException *exc = mono_get_exception_file_not_found (fname);
 875                 mono_raise_exception (exc);
 876         }
 877
 878         return mono_assembly_get_object (domain, ass);
 879 }
 880
 881 static void
 882 free_assembly_name (MonoAssemblyName *aname)
 883 {
 884         if (aname == NULL)
 885                 return;
 886
 887         g_free ((void *) aname->name);
 888         g_free ((void *) aname->culture);
 889         g_free ((void *) aname->hash_value);
 890 }
 891
 892 static gboolean
 893 get_info_from_assembly_name (MonoString *assRef, MonoAssemblyName *aname)
 894 {
 895         gchar *name;
 896         gchar *value;
 897         gchar **parts;
 898         gchar **tmp;
 899         gint major, minor, build, revision;
 900
 901         memset (aname, 0, sizeof (MonoAssemblyName));
 902
 903         name = mono_string_to_utf8 (assRef);
 904         parts = tmp = g_strsplit (name, ",", 4);
 905         g_free (name);
 906         if (!tmp || !*tmp) {
 907                 g_strfreev (tmp);
 908                 return FALSE;
 909         }
 910
 911         value = g_strstrip (*tmp);
 912         /* g_print ("Assembly name: %s\n", value); */
 913         aname->name = g_strdup (value);
 914         tmp++;
 915         if (!*tmp) {
 916                 g_strfreev (parts);
 917                 return TRUE;
 918         }
 919
 920         while (*tmp) {
 921                 value = g_strstrip (*tmp);
 922                 if (!g_ascii_strncasecmp (value, "Version=", 8)) {
 923                         if (sscanf (value + 8, "%u.%u.%u.%u",
 924                                     &major, &minor, &build, &revision) != 4) {
 925                                 g_strfreev (parts);
 926                                 return FALSE;
 927                         }
 928                         /* g_print ("Version: %u.%u.%u.%u\n", major, minor, build, revision); */
 929                         aname->major = major;
 930                         aname->minor = minor;
 931                         aname->build = build;
 932                         aname->revision = revision;
 933                         tmp++;
 934                         continue;
 935                 }
 936
 937                 if (!g_ascii_strncasecmp (value, "Culture=", 8)) {
 938                         gchar *t = g_strdup (value + 8);
 939                         g_strchug (t);
 940                         aname->culture = g_strdup (g_strchomp (t));
 941                         tmp++;
 942                         g_free (t);
 943                         if (g_strcasecmp (aname->culture, "neutral") == 0) {
 944                                 g_free ((void *) aname->culture);
 945                                 aname->culture = g_strdup ("");
 946                         }
 947                         continue;
 948                 }
 949
 950                 if (!g_ascii_strncasecmp (value, "PublicKeyToken=", 15)) {
 951                         tmp++;
 952                         value += 15;
 953                         if (*value && strncmp (value, "null", 4)) {
 954                                 gchar *t = g_strdup (value);
 955                                 g_strchug (t);
 956                                 g_strlcpy (aname->public_key_token, g_strchomp (value), MONO_PUBLIC_KEY_TOKEN_LENGTH);
 957                                 g_free (t);
 958                         }
 959                         continue;
 960                 }
 961
 962                 g_strfreev (parts);
 963                 return FALSE;
 964         }
 965
 966         g_strfreev (parts);
 967         return TRUE;
 968 }
 969
 970 MonoReflectionAssembly *
 971 ves_icall_System_AppDomain_LoadAssemblyRaw (MonoAppDomain *ad,
 972                                                                                         MonoArray *raw_assembly,
 973                                                                                         MonoArray *raw_symbol_store, MonoObject *evidence)
 974 {
 975         MonoAssembly *ass;
 976         MonoReflectionAssembly *refass = NULL;
 977         MonoDomain *domain = ad->data;
 978         MonoImageOpenStatus status;
 979         guint32 raw_assembly_len = mono_array_length (raw_assembly);
 980         MonoImage *image = mono_image_open_from_data (mono_array_addr (raw_assembly, gchar, 0), raw_assembly_len, TRUE, NULL);
 981
 982         if (raw_symbol_store)
 983                 mono_raise_exception (mono_get_exception_not_implemented ("LoadAssemblyRaw: Raw Symbol Store not Implemented"));
 984
 985         if (!image) {
 986                 mono_raise_exception (mono_get_exception_bad_image_format (""));
 987                 return NULL;
 988         }
 989
 990         ass = mono_assembly_load_from (image, "", &status);
 991
 992         if (!ass) {
 993                 mono_image_close (image);
 994                 mono_raise_exception (mono_get_exception_bad_image_format (""));
 995                 return NULL;
 996         }
 997
 998         refass = mono_assembly_get_object (domain, ass);
 999         refass->evidence = evidence;
1000         return refass;
1001 }
1002
1003 MonoReflectionAssembly *
1004 ves_icall_System_AppDomain_LoadAssembly (MonoAppDomain *ad,  MonoString *assRef, MonoObject *evidence)
1005 {
1006         MonoDomain *domain = ad->data;
1007         MonoImageOpenStatus status = MONO_IMAGE_OK;
1008         MonoAssembly *ass;
1009         MonoAssemblyName aname;
1010         MonoReflectionAssembly *refass = NULL;
1011
1012         MONO_ARCH_SAVE_REGS;
1013
1014         g_assert (assRef != NULL);
1015
1016         if (!get_info_from_assembly_name (assRef, &aname)) {
1017                 MonoException *exc;
1018
1019                 free_assembly_name (&aname);
1020                 /* This is a parse error... */
1021                 exc = mono_get_exception_file_not_found (assRef);
1022                 mono_raise_exception (exc);
1023         }
1024
1025         ass = mono_assembly_load (&aname, NULL, &status);
1026         free_assembly_name (&aname);
1027
1028         if (!ass && (refass = try_assembly_resolve (domain, assRef)) == NULL){
1029                 /* FIXME: it doesn't make much sense since we really don't have a filename ... */
1030                 MonoException *exc = mono_get_exception_file_not_found (assRef);
1031                 mono_raise_exception (exc);
1032         }
1033
1034         if (refass == NULL)
1035                 refass = mono_assembly_get_object (domain, ass);
1036
1037         refass->evidence = evidence;
1038         return refass;
1039 }
1040
1041 void
1042 ves_icall_System_AppDomain_InternalUnload (gint32 domain_id)
1043 {
1044         MonoDomain * domain = mono_domain_get_by_id (domain_id);
1045
1046         MONO_ARCH_SAVE_REGS;
1047
1048         if (NULL == domain) {
1049                 MonoException *exc = mono_get_exception_execution_engine ("Failed to unload domain, domain id not found");
1050                 mono_raise_exception (exc);
1051         }
1052
1053         if (domain == mono_get_root_domain ()) {
1054                 mono_raise_exception (mono_get_exception_cannot_unload_appdomain ("The default appdomain can not be unloaded."));
1055                 return;
1056         }
1057
1058         /*
1059          * Unloading seems to cause problems when running NUnit/NAnt, hence
1060          * this workaround.
1061          */
1062         if (g_getenv ("MONO_NO_UNLOAD"))
1063                 return;
1064
1065         mono_domain_unload (domain);
1066 }
1067
1068 gboolean
1069 ves_icall_System_AppDomain_InternalIsFinalizingForUnload (gint32 domain_id)
1070 {
1071         MonoDomain *domain = mono_domain_get_by_id (domain_id);
1072
1073         if (!domain)
1074                 return TRUE;
1075
1076         return mono_domain_is_unloading (domain);
1077 }
1078
1079 gint32
1080 ves_icall_System_AppDomain_ExecuteAssembly (MonoAppDomain *ad, MonoString *file,
1081                                             MonoObject *evidence, MonoArray *args)
1082 {
1083         MonoAssembly *assembly;
1084         MonoImage *image;
1085         MonoMethod *method;
1086         char *filename;
1087         gint32 res;
1088         MonoReflectionAssembly *refass;
1089
1090         MONO_ARCH_SAVE_REGS;
1091
1092         filename = mono_string_to_utf8 (file);
1093         assembly = mono_assembly_open (filename, NULL);
1094         g_free (filename);
1095
1096         if (!assembly)
1097                 mono_raise_exception (mono_get_exception_file_not_found (file));
1098
1099         image = assembly->image;
1100
1101         method = mono_get_method (image, mono_image_get_entry_point (image), NULL);
1102
1103         if (!method)
1104                 g_error ("No entry point method found in %s", image->name);
1105
1106         if (!args)
1107                 args = (MonoArray *) mono_array_new (ad->data, mono_defaults.string_class, 0);
1108
1109         refass = mono_assembly_get_object (ad->data, assembly);
1110         refass->evidence = evidence;
1111
1112         res = mono_runtime_exec_main (method, (MonoArray *)args, NULL);
1113
1114         return res;
1115 }
1116
1117 gint32
1118 ves_icall_System_AppDomain_GetIDFromDomain (MonoAppDomain * ad)
1119 {
1120         MONO_ARCH_SAVE_REGS;
1121
1122         return ad->data->domain_id;
1123 }
1124
1125 MonoAppDomain *
1126 ves_icall_System_AppDomain_InternalSetDomain (MonoAppDomain *ad)
1127 {
1128         MonoDomain *old_domain = mono_domain_get();
1129
1130         MONO_ARCH_SAVE_REGS;
1131
1132         if (!mono_domain_set (ad->data, FALSE))
1133                 mono_raise_exception (mono_get_exception_appdomain_unloaded ());
1134
1135         return old_domain->domain;
1136 }
1137
1138 MonoAppDomain *
1139 ves_icall_System_AppDomain_InternalSetDomainByID (gint32 domainid)
1140 {
1141         MonoDomain *current_domain = mono_domain_get ();
1142         MonoDomain *domain = mono_domain_get_by_id (domainid);
1143
1144         MONO_ARCH_SAVE_REGS;
1145
1146         if (!domain || !mono_domain_set (domain, FALSE))
1147                 mono_raise_exception (mono_get_exception_appdomain_unloaded ());
1148
1149         return current_domain->domain;
1150 }
1151
1152 void
1153 ves_icall_System_AppDomain_InternalPushDomainRef (MonoAppDomain *ad)
1154 {
1155         MONO_ARCH_SAVE_REGS;
1156
1157         mono_thread_push_appdomain_ref (ad->data);
1158 }
1159
1160 void
1161 ves_icall_System_AppDomain_InternalPushDomainRefByID (gint32 domain_id)
1162 {
1163         MonoDomain *domain = mono_domain_get_by_id (domain_id);
1164
1165         MONO_ARCH_SAVE_REGS;
1166
1167         if (!domain)
1168                 /*
1169                  * Raise an exception to prevent the managed code from executing a pop
1170                  * later.
1171                  */
1172                 mono_raise_exception (mono_get_exception_appdomain_unloaded ());
1173
1174         mono_thread_push_appdomain_ref (domain);
1175 }
1176
1177 void
1178 ves_icall_System_AppDomain_InternalPopDomainRef (void)
1179 {
1180         MONO_ARCH_SAVE_REGS;
1181
1182         mono_thread_pop_appdomain_ref ();
1183 }
1184
1185 MonoAppContext *
1186 ves_icall_System_AppDomain_InternalGetContext ()
1187 {
1188         MONO_ARCH_SAVE_REGS;
1189
1190         return mono_context_get ();
1191 }
1192
1193 MonoAppContext *
1194 ves_icall_System_AppDomain_InternalGetDefaultContext ()
1195 {
1196         MONO_ARCH_SAVE_REGS;
1197
1198         return mono_domain_get ()->default_context;
1199 }
1200
1201 MonoAppContext *
1202 ves_icall_System_AppDomain_InternalSetContext (MonoAppContext *mc)
1203 {
1204         MonoAppContext *old_context = mono_context_get ();
1205
1206         MONO_ARCH_SAVE_REGS;
1207
1208         mono_context_set (mc);
1209
1210         return old_context;
1211 }
1212
1213 MonoString *
1214 ves_icall_System_AppDomain_InternalGetProcessGuid (MonoString* newguid)
1215 {
1216         MonoDomain* mono_root_domain = mono_get_root_domain ();
1217         mono_domain_lock (mono_root_domain);
1218         if (process_guid_set) {
1219                 mono_domain_unlock (mono_root_domain);
1220                 return mono_string_new_utf16 (mono_domain_get (), process_guid, sizeof(process_guid)/2);
1221         }
1222         memcpy (process_guid, mono_string_chars(newguid), sizeof(process_guid));
1223         process_guid_set = TRUE;
1224         mono_domain_unlock (mono_root_domain);
1225         return newguid;
1226 }
1227
1228 gboolean
1229 mono_domain_is_unloading (MonoDomain *domain)
1230 {
1231         if (domain->state == MONO_APPDOMAIN_UNLOADING || domain->state == MONO_APPDOMAIN_UNLOADED)
1232                 return TRUE;
1233         else
1234                 return FALSE;
1235 }
1236
1237 static void
1238 clear_cached_vtable (gpointer key, gpointer value, gpointer user_data)
1239 {
1240         MonoClass *klass = (MonoClass*)key;
1241         MonoDomain *domain = (MonoDomain*)user_data;
1242         MonoVTable *vt;
1243
1244         vt = klass->cached_vtable;
1245         if (vt && vt->domain == domain)
1246                 klass->cached_vtable = NULL;
1247 }
1248
1249 typedef struct unload_data {
1250         MonoDomain *domain;
1251         char *failure_reason;
1252 } unload_data;
1253
1254 static guint32
1255 unload_thread_main (void *arg)
1256 {
1257         unload_data *data = (unload_data*)arg;
1258         MonoDomain *domain = data->domain;
1259
1260         /*
1261          * FIXME: Abort our parent thread last, so we can return a failure
1262          * indication if aborting times out.
1263          */
1264         if (!mono_threads_abort_appdomain_threads (domain, 10000)) {
1265                 data->failure_reason = g_strdup_printf ("Aborting of threads in domain %s timed out.", domain->friendly_name);
1266                 return 1;
1267         }
1268
1269         /* Finalize all finalizable objects in the doomed appdomain */
1270         if (!mono_domain_finalize (domain, 10000)) {
1271                 data->failure_reason = g_strdup_printf ("Finalization of domain %s timed out.", domain->friendly_name);
1272                 return 1;
1273         }
1274
1275         /* Clear references to our vtables in class->cached_vtable */
1276         mono_domain_lock (domain);
1277         g_hash_table_foreach (domain->class_vtable_hash, clear_cached_vtable,
1278                                                   domain);
1279         mono_domain_unlock (domain);
1280
1281         mono_threads_clear_cached_culture (domain);
1282
1283         domain->state = MONO_APPDOMAIN_UNLOADED;
1284
1285         /* printf ("UNLOADED %s.\n", domain->friendly_name); */
1286
1287         mono_domain_free (domain, FALSE);
1288
1289         mono_gc_collect (mono_gc_max_generation ());
1290
1291         return 0;
1292 }
1293
1294 /*
1295  * mono_domain_unload:
1296  *
1297  *  Unloads an appdomain. Follows the process outlined in:
1298  *  http://blogs.gotdotnet.com/cbrumme
1299  *  If doing things the 'right' way is too hard or complex, we do it the
1300  *  'simple' way, which means do everything needed to avoid crashes and
1301  *  memory leaks, but not much else.
1302  */
1303 static void
1304 mono_domain_unload (MonoDomain *domain)
1305 {
1306         HANDLE thread_handle;
1307         guint32 tid, res;
1308         MonoAppDomainState prev_state;
1309         MonoMethod *method;
1310         MonoObject *exc;
1311         unload_data thread_data;
1312         MonoDomain *caller_domain = mono_domain_get ();
1313
1314         /* printf ("UNLOAD STARTING FOR %s (%p) IN THREAD 0x%x.\n", domain->friendly_name, domain, GetCurrentThreadId ()); */
1315
1316         /* Atomically change our state to UNLOADING */
1317         prev_state = InterlockedCompareExchange (&domain->state,
1318                                                                                          MONO_APPDOMAIN_UNLOADING,
1319                                                                                          MONO_APPDOMAIN_CREATED);
1320         if (prev_state != MONO_APPDOMAIN_CREATED) {
1321                 if (prev_state == MONO_APPDOMAIN_UNLOADING)
1322                         mono_raise_exception (mono_get_exception_cannot_unload_appdomain ("Appdomain is already being unloaded."));
1323                 else
1324                         if (prev_state == MONO_APPDOMAIN_UNLOADED)
1325                                 mono_raise_exception (mono_get_exception_cannot_unload_appdomain ("Appdomain is already unloaded."));
1326                 else
1327                         g_assert_not_reached ();
1328         }
1329
1330         mono_domain_set (domain, FALSE);
1331         /* Notify OnDomainUnload listeners */
1332         method = mono_class_get_method_from_name (domain->domain->mbr.obj.vtable->klass, "DoDomainUnload", -1);
1333         g_assert (method);
1334
1335         exc = NULL;
1336         mono_runtime_invoke (method, domain->domain, NULL, &exc);
1337         if (exc) {
1338                 /* Roll back the state change */
1339                 domain->state = MONO_APPDOMAIN_CREATED;
1340                 mono_domain_set (caller_domain, FALSE);
1341                 mono_raise_exception ((MonoException*)exc);
1342         }
1343
1344         thread_data.domain = domain;
1345         thread_data.failure_reason = NULL;
1346
1347         /*
1348          * First we create a separate thread for unloading, since
1349          * we might have to abort some threads, including the current one.
1350          */
1351         /*
1352          * If we create a non-suspended thread, the runtime will hang.
1353          * See:
1354          * http://bugzilla.ximian.com/show_bug.cgi?id=27663
1355          */
1356 #if 0
1357         thread_handle = CreateThread (NULL, 0, unload_thread_main, &thread_data, 0, &tid);
1358 #else
1359 #if defined(PLATFORM_WIN32) && defined (HAVE_BOEHM_GC)
1360         thread_handle = GC_CreateThread (NULL, 0, unload_thread_main, &thread_data, CREATE_SUSPENDED, &tid);
1361 #else
1362         thread_handle = CreateThread (NULL, 0, unload_thread_main, &thread_data, CREATE_SUSPENDED, &tid);
1363 #endif
1364         ResumeThread (thread_handle);
1365 #endif
1366
1367         /* Wait for the thread */
1368         while ((res = WaitForSingleObjectEx (thread_handle, INFINITE, TRUE) == WAIT_IO_COMPLETION)) {
1369                 if (mono_thread_has_appdomain_ref (mono_thread_current (), domain) && (mono_thread_interruption_requested ()))
1370                         /* The unload thread tries to abort us */
1371                         /* The icall wrapper will execute the abort */
1372                         return;
1373         }
1374
1375         mono_domain_set (caller_domain, FALSE);
1376
1377         if (thread_data.failure_reason) {
1378                 MonoException *ex;
1379
1380                 /* Roll back the state change */
1381                 domain->state = MONO_APPDOMAIN_CREATED;
1382
1383                 g_warning (thread_data.failure_reason);
1384
1385                 g_free (thread_data.failure_reason);
1386                 thread_data.failure_reason = NULL;
1387
1388                 ex = mono_get_exception_cannot_unload_appdomain (thread_data.failure_reason);
1389
1390                 mono_raise_exception (ex);
1391         }
1392 }