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