mono/metadata/domain.c

   1
   2 /*
   3  * domain.c: MonoDomain functions
   4  *
   5  * Author:
   6  *      Dietmar Maurer (dietmar@ximian.com)
   7  *      Patrik Torstensson
   8  *
   9  * (C) 2001 Ximian, Inc.
  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/appdomain.h>
  20 #include <mono/metadata/assembly.h>
  21 #include <mono/metadata/exception.h>
  22 #include <mono/metadata/cil-coff.h>
  23 #include <mono/metadata/rawbuffer.h>
  24
  25 //#define DEBUG_DOMAIN_UNLOAD
  26
  27 static guint32 appdomain_thread_id = -1;
  28 static guint32 context_thread_id = -1;
  29
  30 static gint32 appdomain_id_counter = 0;
  31
  32 static MonoGHashTable * appdomains_list = NULL;
  33
  34 static CRITICAL_SECTION appdomains_mutex;
  35
  36 MonoDomain *mono_root_domain = NULL;
  37
  38 static MonoJitInfoTable *
  39 mono_jit_info_table_new (void)
  40 {
  41         return g_array_new (FALSE, FALSE, sizeof (gpointer));
  42 }
  43
  44 static void
  45 mono_jit_info_table_free (MonoJitInfoTable *table)
  46 {
  47         g_array_free (table, TRUE);
  48 }
  49
  50 static int
  51 mono_jit_info_table_index (MonoJitInfoTable *table, char *addr)
  52 {
  53         int left = 0, right = table->len;
  54
  55         while (left < right) {
  56                 int pos = (left + right) / 2;
  57                 MonoJitInfo *ji = g_array_index (table, gpointer, pos);
  58                 char *start = ji->code_start;
  59                 char *end = start + ji->code_size;
  60
  61                 if (addr < start)
  62                         right = pos;
  63                 else if (addr >= end)
  64                         left = pos + 1;
  65                 else
  66                         return pos;
  67         }
  68
  69         return left;
  70 }
  71
  72 MonoJitInfo *
  73 mono_jit_info_table_find (MonoDomain *domain, char *addr)
  74 {
  75         MonoJitInfoTable *table = domain->jit_info_table;
  76         int left = 0, right;
  77
  78         mono_domain_lock (domain);
  79
  80         right = table->len;
  81         while (left < right) {
  82                 int pos = (left + right) / 2;
  83                 MonoJitInfo *ji = g_array_index (table, gpointer, pos);
  84                 char *start = ji->code_start;
  85                 char *end = start + ji->code_size;
  86
  87                 if (addr < start)
  88                         right = pos;
  89                 else if (addr >= end)
  90                         left = pos + 1;
  91                 else {
  92                         mono_domain_unlock (domain);
  93                         return ji;
  94                 }
  95         }
  96         mono_domain_unlock (domain);
  97
  98         /* maybe it is shared code, so we also search in the root domain */
  99         if (domain != mono_root_domain)
 100                 return mono_jit_info_table_find (mono_root_domain, addr);
 101
 102         return NULL;
 103 }
 104
 105 void
 106 mono_jit_info_table_add (MonoDomain *domain, MonoJitInfo *ji)
 107 {
 108         MonoJitInfoTable *table = domain->jit_info_table;
 109         gpointer start = ji->code_start;
 110         int pos;
 111
 112         mono_domain_lock (domain);
 113         pos = mono_jit_info_table_index (table, start);
 114
 115         g_array_insert_val (table, pos, ji);
 116         mono_domain_unlock (domain);
 117 }
 118
 119 static int
 120 ldstr_hash (const char* str)
 121 {
 122         guint len, h;
 123         const char *end;
 124         len = mono_metadata_decode_blob_size (str, &str) - 1;
 125         end = str + len;
 126         /* if len == 0 *str will point to the mark byte */
 127         h = len? *str: 0;
 128         /*
 129          * FIXME: The distribution may not be so nice with lots of
 130          * null chars in the string.
 131          */
 132         for (str += 1; str < end; str++)
 133                 h = (h << 5) - h + *str;
 134         return h;
 135 }
 136
 137 static gboolean
 138 ldstr_equal (const char *str1, const char *str2) {
 139         int len, len2;
 140         if (str1 == str2)
 141                 return TRUE;
 142         len = mono_metadata_decode_blob_size (str1, NULL) - 1;
 143         len2 = mono_metadata_decode_blob_size (str2, NULL) - 1;
 144         if (len != len2)
 145                 return 0;
 146         return memcmp (str1, str2, len) == 0;
 147 }
 148
 149 static gboolean
 150 mono_string_equal (MonoString *s1, MonoString *s2)
 151 {
 152         int l1 = mono_string_length (s1);
 153         int l2 = mono_string_length (s2);
 154
 155         if (l1 != l2)
 156                 return FALSE;
 157
 158         return memcmp (mono_string_chars (s1), mono_string_chars (s2), l1) == 0;
 159 }
 160
 161 static guint
 162 mono_string_hash (MonoString *s)
 163 {
 164         const guint16 *p = mono_string_chars (s);
 165         int i, len = mono_string_length (s);
 166         guint h = 0;
 167
 168         for (i = 0; i < len; i++) {
 169                 h = (h << 5) - h + *p;
 170                 p++;
 171         }
 172
 173         return h;
 174 }
 175
 176 #if HAVE_BOEHM_GC
 177 static void
 178 domain_finalizer (void *obj, void *data) {
 179         g_print ("domain finalized\n");
 180 }
 181 #endif
 182
 183 MonoDomain *
 184 mono_domain_create (void)
 185 {
 186         MonoDomain *domain;
 187
 188 #if HAVE_BOEHM_GC
 189         domain = GC_MALLOC (sizeof (MonoDomain));
 190         GC_REGISTER_FINALIZER (domain, domain_finalizer, NULL, NULL, NULL);
 191 #else
 192         domain = g_new0 (MonoDomain, 1);
 193 #endif
 194         domain->domain = NULL;
 195         domain->setup = NULL;
 196         domain->friendly_name = NULL;
 197         domain->search_path = NULL;
 198
 199         domain->mp = mono_mempool_new ();
 200         domain->code_mp = mono_code_manager_new ();
 201         domain->env = mono_g_hash_table_new ((GHashFunc)mono_string_hash, (GCompareFunc)mono_string_equal);
 202         domain->assemblies = g_hash_table_new (g_str_hash, g_str_equal);
 203         domain->class_vtable_hash = mono_g_hash_table_new (NULL, NULL);
 204         domain->proxy_vtable_hash = mono_g_hash_table_new ((GHashFunc)mono_string_hash, (GCompareFunc)mono_string_equal);
 205         domain->static_data_hash = mono_g_hash_table_new (NULL, NULL);
 206         domain->jit_code_hash = g_hash_table_new (NULL, NULL);
 207         domain->ldstr_table = mono_g_hash_table_new ((GHashFunc)ldstr_hash, (GCompareFunc)ldstr_equal);
 208         domain->jit_info_table = mono_jit_info_table_new ();
 209         domain->class_init_trampoline_hash = mono_g_hash_table_new (NULL, NULL);
 210         domain->finalizable_objects_hash = g_hash_table_new (NULL, NULL);
 211         domain->domain_id = InterlockedIncrement (&appdomain_id_counter);
 212
 213         InitializeCriticalSection (&domain->lock);
 214
 215         EnterCriticalSection (&appdomains_mutex);
 216         mono_g_hash_table_insert(appdomains_list, GINT_TO_POINTER(domain->domain_id), domain);
 217         LeaveCriticalSection (&appdomains_mutex);
 218
 219         return domain;
 220 }
 221
 222 /**
 223  * mono_init:
 224  *
 225  * Creates the initial application domain and initializes the mono_defaults
 226  * structure.
 227  * This function is guaranteed to not run any IL code.
 228  *
 229  * Returns: the initial domain.
 230  */
 231 MonoDomain *
 232 mono_init (const char *filename)
 233 {
 234         static MonoDomain *domain = NULL;
 235         MonoAssembly *ass;
 236         MonoImageOpenStatus status = MONO_IMAGE_OK;
 237         MonoAssemblyName corlib_aname;
 238
 239         if (domain)
 240                 g_assert_not_reached ();
 241
 242         appdomain_thread_id = TlsAlloc ();
 243         context_thread_id = TlsAlloc ();
 244
 245         InitializeCriticalSection (&appdomains_mutex);
 246
 247         mono_metadata_init ();
 248         mono_raw_buffer_init ();
 249         mono_images_init ();
 250         mono_assemblies_init ();
 251         mono_loader_init ();
 252
 253         // FIXME: When should we release this memory?
 254         appdomains_list = mono_g_hash_table_new (g_direct_hash, g_direct_equal);
 255
 256         domain = mono_domain_create ();
 257         mono_root_domain = domain;
 258
 259         TlsSetValue (appdomain_thread_id, domain);
 260
 261         /* find the corlib */
 262         corlib_aname.name = "mscorlib";
 263         ass = mono_assembly_load (&corlib_aname, NULL, &status);
 264         if ((status != MONO_IMAGE_OK) || (ass == NULL)) {
 265                 switch (status){
 266                 case MONO_IMAGE_ERROR_ERRNO:
 267                         g_print ("The assembly mscorlib.dll was not found or could not be loaded.\n");
 268                         g_print ("It should have been installed in the `%s' directory.\n",
 269                                  mono_assembly_getrootdir ());
 270                         break;
 271                 case MONO_IMAGE_IMAGE_INVALID:
 272                         g_print ("The file %s/mscorlib.dll is an invalid CIL image\n",
 273                                  mono_assembly_getrootdir ());
 274                         break;
 275                 case MONO_IMAGE_MISSING_ASSEMBLYREF:
 276                         g_print ("Missing assembly reference in %s/mscorlib.dll\n",
 277                                  mono_assembly_getrootdir ());
 278                         break;
 279                 case MONO_IMAGE_OK:
 280                         /* to suppress compiler warning */
 281                         break;
 282                 }
 283
 284                 exit (1);
 285         }
 286         mono_defaults.corlib = ass->image;
 287
 288         mono_defaults.object_class = mono_class_from_name (
 289                 mono_defaults.corlib, "System", "Object");
 290         g_assert (mono_defaults.object_class != 0);
 291
 292         mono_defaults.void_class = mono_class_from_name (
 293                 mono_defaults.corlib, "System", "Void");
 294         g_assert (mono_defaults.void_class != 0);
 295
 296         mono_defaults.boolean_class = mono_class_from_name (
 297                 mono_defaults.corlib, "System", "Boolean");
 298         g_assert (mono_defaults.boolean_class != 0);
 299
 300         mono_defaults.byte_class = mono_class_from_name (
 301                 mono_defaults.corlib, "System", "Byte");
 302         g_assert (mono_defaults.byte_class != 0);
 303
 304         mono_defaults.sbyte_class = mono_class_from_name (
 305                 mono_defaults.corlib, "System", "SByte");
 306         g_assert (mono_defaults.sbyte_class != 0);
 307
 308         mono_defaults.int16_class = mono_class_from_name (
 309                 mono_defaults.corlib, "System", "Int16");
 310         g_assert (mono_defaults.int16_class != 0);
 311
 312         mono_defaults.uint16_class = mono_class_from_name (
 313                 mono_defaults.corlib, "System", "UInt16");
 314         g_assert (mono_defaults.uint16_class != 0);
 315
 316         mono_defaults.int32_class = mono_class_from_name (
 317                 mono_defaults.corlib, "System", "Int32");
 318         g_assert (mono_defaults.int32_class != 0);
 319
 320         mono_defaults.uint32_class = mono_class_from_name (
 321                 mono_defaults.corlib, "System", "UInt32");
 322         g_assert (mono_defaults.uint32_class != 0);
 323
 324         mono_defaults.uint_class = mono_class_from_name (
 325                 mono_defaults.corlib, "System", "UIntPtr");
 326         g_assert (mono_defaults.uint_class != 0);
 327
 328         mono_defaults.int_class = mono_class_from_name (
 329                 mono_defaults.corlib, "System", "IntPtr");
 330         g_assert (mono_defaults.int_class != 0);
 331
 332         mono_defaults.int64_class = mono_class_from_name (
 333                 mono_defaults.corlib, "System", "Int64");
 334         g_assert (mono_defaults.int64_class != 0);
 335
 336         mono_defaults.uint64_class = mono_class_from_name (
 337                 mono_defaults.corlib, "System", "UInt64");
 338         g_assert (mono_defaults.uint64_class != 0);
 339
 340         mono_defaults.single_class = mono_class_from_name (
 341                 mono_defaults.corlib, "System", "Single");
 342         g_assert (mono_defaults.single_class != 0);
 343
 344         mono_defaults.double_class = mono_class_from_name (
 345                 mono_defaults.corlib, "System", "Double");
 346         g_assert (mono_defaults.double_class != 0);
 347
 348         mono_defaults.char_class = mono_class_from_name (
 349                 mono_defaults.corlib, "System", "Char");
 350         g_assert (mono_defaults.char_class != 0);
 351
 352         mono_defaults.string_class = mono_class_from_name (
 353                 mono_defaults.corlib, "System", "String");
 354         g_assert (mono_defaults.string_class != 0);
 355
 356         mono_defaults.enum_class = mono_class_from_name (
 357                 mono_defaults.corlib, "System", "Enum");
 358         g_assert (mono_defaults.enum_class != 0);
 359
 360         mono_defaults.array_class = mono_class_from_name (
 361                 mono_defaults.corlib, "System", "Array");
 362         g_assert (mono_defaults.array_class != 0);
 363
 364         mono_defaults.delegate_class = mono_class_from_name (
 365                 mono_defaults.corlib, "System", "Delegate");
 366         g_assert (mono_defaults.delegate_class != 0 );
 367
 368         mono_defaults.multicastdelegate_class = mono_class_from_name (
 369                 mono_defaults.corlib, "System", "MulticastDelegate");
 370         g_assert (mono_defaults.multicastdelegate_class != 0 );
 371
 372         mono_defaults.asyncresult_class = mono_class_from_name (
 373                 mono_defaults.corlib, "System.Runtime.Remoting.Messaging",
 374                 "AsyncResult");
 375         g_assert (mono_defaults.asyncresult_class != 0 );
 376
 377         mono_defaults.waithandle_class = mono_class_from_name (
 378                 mono_defaults.corlib, "System.Threading", "WaitHandle");
 379         g_assert (mono_defaults.waithandle_class != 0 );
 380
 381         mono_defaults.typehandle_class = mono_class_from_name (
 382                 mono_defaults.corlib, "System", "RuntimeTypeHandle");
 383         g_assert (mono_defaults.typehandle_class != 0);
 384
 385         mono_defaults.methodhandle_class = mono_class_from_name (
 386                 mono_defaults.corlib, "System", "RuntimeMethodHandle");
 387         g_assert (mono_defaults.methodhandle_class != 0);
 388
 389         mono_defaults.fieldhandle_class = mono_class_from_name (
 390                 mono_defaults.corlib, "System", "RuntimeFieldHandle");
 391         g_assert (mono_defaults.fieldhandle_class != 0);
 392
 393         mono_defaults.monotype_class = mono_class_from_name (
 394                 mono_defaults.corlib, "System", "MonoType");
 395         g_assert (mono_defaults.monotype_class != 0);
 396
 397         mono_defaults.exception_class = mono_class_from_name (
 398                 mono_defaults.corlib, "System", "Exception");
 399         g_assert (mono_defaults.exception_class != 0);
 400
 401         mono_defaults.threadabortexception_class = mono_class_from_name (
 402                 mono_defaults.corlib, "System.Threading", "ThreadAbortException");
 403         g_assert (mono_defaults.threadabortexception_class != 0);
 404
 405         mono_defaults.thread_class = mono_class_from_name (
 406                 mono_defaults.corlib, "System.Threading", "Thread");
 407         g_assert (mono_defaults.thread_class != 0);
 408
 409         mono_defaults.appdomain_class = mono_class_from_name (
 410                 mono_defaults.corlib, "System", "AppDomain");
 411         g_assert (mono_defaults.appdomain_class != 0);
 412
 413         mono_defaults.transparent_proxy_class = mono_class_from_name (
 414                 mono_defaults.corlib, "System.Runtime.Remoting.Proxies", "TransparentProxy");
 415         g_assert (mono_defaults.transparent_proxy_class != 0);
 416
 417         mono_defaults.real_proxy_class = mono_class_from_name (
 418                 mono_defaults.corlib, "System.Runtime.Remoting.Proxies", "RealProxy");
 419         g_assert (mono_defaults.real_proxy_class != 0);
 420
 421         mono_defaults.mono_method_message_class = mono_class_from_name (
 422                 mono_defaults.corlib, "System.Runtime.Remoting.Messaging", "MonoMethodMessage");
 423         g_assert (mono_defaults.mono_method_message_class != 0);
 424
 425         mono_defaults.field_info_class = mono_class_from_name (
 426                 mono_defaults.corlib, "System.Reflection", "FieldInfo");
 427         g_assert (mono_defaults.field_info_class != 0);
 428
 429         mono_defaults.method_info_class = mono_class_from_name (
 430                 mono_defaults.corlib, "System.Reflection", "MethodInfo");
 431         g_assert (mono_defaults.method_info_class != 0);
 432
 433         mono_defaults.stringbuilder_class = mono_class_from_name (
 434                 mono_defaults.corlib, "System.Text", "StringBuilder");
 435         g_assert (mono_defaults.stringbuilder_class != 0);
 436
 437         mono_defaults.math_class = mono_class_from_name (
 438                 mono_defaults.corlib, "System", "Math");
 439         g_assert (mono_defaults.math_class != 0);
 440
 441         mono_defaults.stack_frame_class = mono_class_from_name (
 442                 mono_defaults.corlib, "System.Diagnostics", "StackFrame");
 443         g_assert (mono_defaults.stack_frame_class != 0);
 444
 445         mono_defaults.stack_trace_class = mono_class_from_name (
 446                 mono_defaults.corlib, "System.Diagnostics", "StackTrace");
 447         g_assert (mono_defaults.stack_trace_class != 0);
 448
 449         mono_defaults.marshal_class = mono_class_from_name (
 450                 mono_defaults.corlib, "System.Runtime.InteropServices", "Marshal");
 451         g_assert (mono_defaults.marshal_class != 0);
 452
 453         mono_defaults.iserializeable_class = mono_class_from_name (
 454                 mono_defaults.corlib, "System.Runtime.Serialization", "ISerializable");
 455         g_assert (mono_defaults.iserializeable_class != 0);
 456
 457         mono_defaults.serializationinfo_class = mono_class_from_name (
 458                 mono_defaults.corlib, "System.Runtime.Serialization", "SerializationInfo");
 459         g_assert (mono_defaults.serializationinfo_class != 0);
 460
 461         mono_defaults.streamingcontext_class = mono_class_from_name (
 462                 mono_defaults.corlib, "System.Runtime.Serialization", "StreamingContext");
 463         g_assert (mono_defaults.streamingcontext_class != 0);
 464
 465         mono_defaults.typed_reference_class =  mono_class_from_name (
 466                 mono_defaults.corlib, "System", "TypedReference");
 467         g_assert (mono_defaults.typed_reference_class != 0);
 468
 469         mono_defaults.argumenthandle_class =  mono_class_from_name (
 470                 mono_defaults.corlib, "System", "RuntimeArgumentHandle");
 471         g_assert (mono_defaults.argumenthandle_class != 0);
 472
 473         mono_defaults.marshalbyrefobject_class =  mono_class_from_name (
 474                 mono_defaults.corlib, "System", "MarshalByRefObject");
 475         g_assert (mono_defaults.marshalbyrefobject_class != 0);
 476
 477         mono_defaults.monitor_class =  mono_class_from_name (
 478                 mono_defaults.corlib, "System.Threading", "Monitor");
 479         g_assert (mono_defaults.monitor_class != 0);
 480
 481         mono_defaults.iremotingtypeinfo_class = mono_class_from_name (
 482                 mono_defaults.corlib, "System.Runtime.Remoting", "IRemotingTypeInfo");
 483         g_assert (mono_defaults.iremotingtypeinfo_class != 0);
 484
 485         domain->friendly_name = g_path_get_basename (filename);
 486
 487         return domain;
 488 }
 489
 490 /**
 491  * mono_domain_get:
 492  *
 493  * Returns the current domain.
 494  */
 495 inline MonoDomain *
 496 mono_domain_get ()
 497 {
 498         return ((MonoDomain *)TlsGetValue (appdomain_thread_id));
 499 }
 500
 501 /**
 502  * mono_domain_set_internal:
 503  * @domain: the new domain
 504  *
 505  * Sets the current domain to @domain.
 506  */
 507 inline void
 508 mono_domain_set_internal (MonoDomain *domain)
 509 {
 510         TlsSetValue (appdomain_thread_id, domain);
 511         TlsSetValue (context_thread_id, domain->default_context);
 512 }
 513
 514 typedef struct {
 515         MonoDomainFunc func;
 516         gpointer user_data;
 517 } DomainInfo;
 518
 519 static void
 520 copy_hash_entry (gpointer key, gpointer data, gpointer user_data)
 521 {
 522         MonoGHashTable *dest = (MonoGHashTable*)user_data;
 523
 524         mono_g_hash_table_insert (dest, key, data);
 525 }
 526
 527 static void
 528 foreach_domain (gpointer key, gpointer data, gpointer user_data)
 529 {
 530         DomainInfo *dom_info = user_data;
 531
 532         dom_info->func ((MonoDomain*)data, dom_info->user_data);
 533 }
 534
 535 void
 536 mono_domain_foreach (MonoDomainFunc func, gpointer user_data)
 537 {
 538         DomainInfo dom_info;
 539         MonoGHashTable *copy;
 540
 541         /*
 542          * Create a copy of the hashtable to avoid calling the user callback
 543          * inside the lock because that could lead to deadlocks.
 544          * We can do this because this function is not perf. critical.
 545          */
 546         copy = mono_g_hash_table_new (NULL, NULL);
 547         EnterCriticalSection (&appdomains_mutex);
 548         mono_g_hash_table_foreach (appdomains_list, copy_hash_entry, copy);
 549         LeaveCriticalSection (&appdomains_mutex);
 550
 551         dom_info.func = func;
 552         dom_info.user_data = user_data;
 553         mono_g_hash_table_foreach (copy, foreach_domain, &dom_info);
 554
 555         mono_g_hash_table_destroy (copy);
 556 }
 557
 558 /**
 559  * mono_domain_assembly_open:
 560  * @domain: the application domain
 561  * @name: file name of the assembly
 562  *
 563  * fixme: maybe we should integrate this with mono_assembly_open ??
 564  */
 565 MonoAssembly *
 566 mono_domain_assembly_open (MonoDomain *domain, const char *name)
 567 {
 568         MonoAssembly *ass;
 569
 570         mono_domain_lock (domain);
 571         if ((ass = g_hash_table_lookup (domain->assemblies, name))) {
 572                 mono_domain_unlock (domain);
 573                 return ass;
 574         }
 575         mono_domain_unlock (domain);
 576
 577         if (!(ass = mono_assembly_open (name, NULL)))
 578                 return NULL;
 579
 580         return ass;
 581 }
 582
 583 static void
 584 remove_assembly (gpointer key, gpointer value, gpointer user_data)
 585 {
 586         mono_assembly_close ((MonoAssembly *)value);
 587 }
 588
 589 static void
 590 delete_jump_list (gpointer key, gpointer value, gpointer user_data)
 591 {
 592         g_slist_free (value);
 593 }
 594
 595 void
 596 mono_domain_free (MonoDomain *domain, gboolean force)
 597 {
 598         if ((domain == mono_root_domain) && !force) {
 599                 g_warning ("cant unload root domain");
 600                 return;
 601         }
 602
 603         EnterCriticalSection (&appdomains_mutex);
 604         mono_g_hash_table_remove (appdomains_list, GINT_TO_POINTER(domain->domain_id));
 605         LeaveCriticalSection (&appdomains_mutex);
 606
 607         g_free (domain->friendly_name);
 608         g_hash_table_foreach (domain->assemblies, remove_assembly, NULL);
 609
 610         mono_g_hash_table_destroy (domain->env);
 611         g_hash_table_destroy (domain->assemblies);
 612         mono_g_hash_table_destroy (domain->class_vtable_hash);
 613         mono_g_hash_table_destroy (domain->proxy_vtable_hash);
 614         mono_g_hash_table_destroy (domain->static_data_hash);
 615         g_hash_table_destroy (domain->jit_code_hash);
 616         mono_g_hash_table_destroy (domain->ldstr_table);
 617         mono_jit_info_table_free (domain->jit_info_table);
 618 #ifdef DEBUG_DOMAIN_UNLOAD
 619         mono_mempool_invalidate (domain->mp);
 620         mono_code_manager_invalidate (domain->code_mp);
 621 #else
 622         mono_mempool_destroy (domain->mp);
 623         mono_code_manager_destroy (domain->code_mp);
 624 #endif
 625         if (domain->jump_target_hash) {
 626                 g_hash_table_foreach (domain->jump_target_hash, delete_jump_list, NULL);
 627                 g_hash_table_destroy (domain->jump_target_hash);
 628         }
 629         mono_g_hash_table_destroy (domain->class_init_trampoline_hash);
 630         g_hash_table_destroy (domain->finalizable_objects_hash);
 631         if (domain->special_static_fields)
 632                 g_hash_table_destroy (domain->special_static_fields);
 633         DeleteCriticalSection (&domain->lock);
 634         domain->setup = NULL;
 635
 636         /* FIXME: anything else required ? */
 637
 638 #if HAVE_BOEHM_GC
 639 #else
 640         g_free (domain);
 641 #endif
 642
 643         if ((domain == mono_root_domain))
 644                 mono_root_domain = NULL;
 645 }
 646
 647 /**
 648  * mono_domain_get_id:
 649  *
 650  * Returns the a domain for a specific domain id.
 651  */
 652 MonoDomain *
 653 mono_domain_get_by_id (gint32 domainid)
 654 {
 655         MonoDomain * domain;
 656
 657         EnterCriticalSection (&appdomains_mutex);
 658         domain = mono_g_hash_table_lookup (appdomains_list, GINT_TO_POINTER(domainid));
 659         LeaveCriticalSection (&appdomains_mutex);
 660
 661         return domain;
 662 }
 663
 664 void
 665 mono_context_set (MonoAppContext * new_context)
 666 {
 667         TlsSetValue (context_thread_id, new_context);
 668 }
 669
 670 MonoAppContext *
 671 mono_context_get ()
 672 {
 673         return ((MonoAppContext *)TlsGetValue (context_thread_id));
 674 }