X-Git-Url: http://wien.tomnetworks.com/gitweb/?a=blobdiff_plain;f=mono%2Fmetadata%2Fdomain-internals.h;h=815f605c4457d321b4fcda6e46a51c352c300029;hb=3ba9a5b1066a81d5198c7f59ac268c5c51508592;hp=fe9c90d2257e5d6630ae44de52182237d5ade631;hpb=4e5e61cf501ef587ec36aaf80d04d734ca0efaca;p=mono.git diff --git a/mono/metadata/domain-internals.h b/mono/metadata/domain-internals.h index fe9c90d2257..815f605c445 100644 --- a/mono/metadata/domain-internals.h +++ b/mono/metadata/domain-internals.h @@ -5,13 +5,17 @@ #define __MONO_METADATA_DOMAIN_INTERNALS_H__ #include +#include +#include #include -#include +#include #include #include #include +#include extern CRITICAL_SECTION mono_delegate_section; +extern CRITICAL_SECTION mono_strtod_mutex; /* * If this is set, the memory belonging to appdomains is not freed when a domain is @@ -41,10 +45,11 @@ typedef struct { MonoBoolean disallow_code_downloads; MonoObject *activation_arguments; /* it is System.Object in 1.x, ActivationArguments in 2.0 */ MonoObject *domain_initializer; - MonoArray *domain_initializer_args; MonoObject *application_trust; /* it is System.Object in 1.x, ApplicationTrust in 2.0 */ + MonoArray *domain_initializer_args; MonoBoolean disallow_appbase_probe; MonoArray *configuration_bytes; + MonoArray *serialized_non_primitives; } MonoAppDomainSetup; typedef struct _MonoJitInfoTable MonoJitInfoTable; @@ -67,6 +72,8 @@ struct _MonoJitInfoTable MonoJitInfoTableChunk *chunks [MONO_ZERO_LEN_ARRAY]; }; +#define MONO_SIZEOF_JIT_INFO_TABLE (sizeof (struct _MonoJitInfoTable) - MONO_ZERO_LEN_ARRAY * SIZEOF_VOID_P) + typedef GArray MonoAotModuleInfoTable; typedef struct { @@ -78,6 +85,7 @@ typedef struct { union { MonoClass *catch_class; gpointer filter; + gpointer handler_end; } data; } MonoJitExceptionInfo; @@ -98,6 +106,42 @@ typedef struct gboolean this_in_reg:1; } MonoGenericJitInfo; +/* +A try block hole is used to represent a non-contiguous part of +of a segment of native code protected by a given .try block. +Usually, a try block is defined as a contiguous segment of code. +But in some cases it's needed to have some parts of it to not be protected. +For example, given "try {} finally {}", the code in the .try block to call +the finally part looks like: + +try { + ... + call finally_block + adjust stack + jump outside try block + ... +} finally { + ... +} + +The instructions between the call and the jump should not be under the try block since they happen +after the finally block executes, which means if an async exceptions happens at that point we would +execute the finally clause twice. So, to avoid this, we introduce a hole in the try block to signal +that those instructions are not protected. +*/ +typedef struct +{ + guint32 offset; + guint16 clause; + guint16 length; +} MonoTryBlockHoleJitInfo; + +typedef struct +{ + guint16 num_holes; + MonoTryBlockHoleJitInfo holes [MONO_ZERO_LEN_ARRAY]; +} MonoTryBlockHoleTableJitInfo; + struct _MonoJitInfo { /* NOTE: These first two elements (method and next_jit_code_hash) must be in the same order and at the @@ -106,9 +150,10 @@ struct _MonoJitInfo { MonoMethod *method; struct _MonoJitInfo *next_jit_code_hash; gpointer code_start; + /* This might contain an id for the unwind info instead of a register mask */ guint32 used_regs; int code_size; - guint32 num_clauses:16; + guint32 num_clauses:15; /* Whenever the code is domain neutral or 'shared' */ gboolean domain_neutral:1; gboolean cas_inited:1; @@ -119,10 +164,20 @@ struct _MonoJitInfo { gboolean cas_method_deny:1; gboolean cas_method_permitonly:1; gboolean has_generic_jit_info:1; + gboolean has_try_block_holes:1; + gboolean from_aot:1; + gboolean from_llvm:1; + + /* FIXME: Embed this after the structure later*/ + gpointer gc_info; /* Currently only used by SGen */ + MonoJitExceptionInfo clauses [MONO_ZERO_LEN_ARRAY]; /* There is an optional MonoGenericJitInfo after the clauses */ + /* There is an optional MonoTryBlockHoleTableJitInfo after MonoGenericJitInfo clauses*/ }; +#define MONO_SIZEOF_JIT_INFO (offsetof (struct _MonoJitInfo, clauses)) + struct _MonoAppContext { MonoObject obj; gint32 domain_id; @@ -130,8 +185,16 @@ struct _MonoAppContext { gpointer *static_data; }; +/* + * We have two unloading states because the domain + * must remain fully functional while AppDomain::DomainUnload is + * processed. + * After that unloading began and all domain facilities are teared down + * such as execution of new threadpool jobs. + */ typedef enum { MONO_APPDOMAIN_CREATED, + MONO_APPDOMAIN_UNLOADING_START, MONO_APPDOMAIN_UNLOADING, MONO_APPDOMAIN_UNLOADED } MonoAppDomainState; @@ -145,6 +208,11 @@ typedef struct _MonoThunkFreeList { typedef struct _MonoJitCodeHash MonoJitCodeHash; struct _MonoDomain { + /* + * This lock must never be taken before the loader lock, + * i.e. if both are taken by the same thread, the loader lock + * must taken first. + */ CRITICAL_SECTION lock; MonoMemPool *mp; MonoCodeManager *code_mp; @@ -159,6 +227,16 @@ struct _MonoDomain { MonoException *out_of_memory_ex; MonoException *null_reference_ex; MonoException *stack_overflow_ex; + /* typeof (void) */ + MonoObject *typeof_void; + /* Ephemeron Tombstone*/ + MonoObject *ephemeron_tombstone; + /* new MonoType [0] */ + MonoArray *empty_types; + /* + * The fields between FIRST_GC_TRACKED and LAST_GC_TRACKED are roots, but + * not object references. + */ #define MONO_DOMAIN_FIRST_GC_TRACKED env MonoGHashTable *env; MonoGHashTable *ldstr_table; @@ -171,9 +249,7 @@ struct _MonoDomain { MonoGHashTable *type_init_exception_hash; /* maps delegate trampoline addr -> delegate object */ MonoGHashTable *delegate_hash_table; - /* typeof (void) */ - MonoObject *typeof_void; -#define MONO_DOMAIN_LAST_GC_TRACKED typeof_void +#define MONO_DOMAIN_LAST_GC_TRACKED delegate_hash_table guint32 state; /* Needed by Thread:GetDomainID() */ gint32 domain_id; @@ -182,7 +258,7 @@ struct _MonoDomain { GSList *domain_assemblies; MonoAssembly *entry_assembly; char *friendly_name; - GHashTable *class_vtable_hash; + GPtrArray *class_vtable_array; /* maps remote class key -> MonoRemoteClass */ GHashTable *proxy_vtable_hash; /* Protected by 'jit_code_hash_lock' */ @@ -206,10 +282,18 @@ struct _MonoDomain { * if the hashtable contains a GC visible reference to them. */ GHashTable *finalizable_objects_hash; + + /* These two are boehm only */ + /* Maps MonoObjects to a GSList of WeakTrackResurrection GCHandles pointing to them */ + GHashTable *track_resurrection_objects_hash; + /* Maps WeakTrackResurrection GCHandles to the MonoObjects they point to */ + GHashTable *track_resurrection_handles_hash; + + /* Protects the three hashes above */ + CRITICAL_SECTION finalizable_objects_hash_lock; /* Used when accessing 'domain_assemblies' */ CRITICAL_SECTION assemblies_lock; - GHashTable *shared_generics_hash; GHashTable *method_rgctx_hash; GHashTable *generic_virtual_cases; @@ -219,8 +303,35 @@ struct _MonoDomain { gpointer runtime_info; /*thread pool jobs, used to coordinate shutdown.*/ - int threadpool_jobs; + volatile int threadpool_jobs; HANDLE cleanup_semaphore; + + /* Contains the compiled runtime invoke wrapper used by finalizers */ + gpointer finalize_runtime_invoke; + + /* Contains the compiled runtime invoke wrapper used by async resylt creation to capture thread context*/ + gpointer capture_context_runtime_invoke; + + /* Contains the compiled method used by async resylt creation to capture thread context*/ + gpointer capture_context_method; + + /* Assembly bindings, the per-domain part */ + GSList *assembly_bindings; + gboolean assembly_bindings_parsed; + + /* Used by socket-io.c */ + /* These are domain specific, since the assembly can be unloaded */ + MonoImage *socket_assembly; + MonoClass *sockaddr_class; + MonoClassField *sockaddr_data_field; + + /* Used by threadpool.c */ + MonoImage *system_image; + MonoImage *system_net_dll; + MonoClass *corlib_asyncresult_class; + MonoClass *socket_class; + MonoClass *ad_unloaded_ex_class; + MonoClass *process_class; }; typedef struct { @@ -231,15 +342,15 @@ typedef struct { typedef struct { const char runtime_version [12]; const char framework_version [4]; - const AssemblyVersionSet version_sets [2]; + const AssemblyVersionSet version_sets [3]; } MonoRuntimeInfo; -#define mono_domain_lock(domain) EnterCriticalSection(&(domain)->lock) -#define mono_domain_unlock(domain) LeaveCriticalSection(&(domain)->lock) -#define mono_domain_assemblies_lock(domain) EnterCriticalSection(&(domain)->assemblies_lock) -#define mono_domain_assemblies_unlock(domain) LeaveCriticalSection(&(domain)->assemblies_lock) -#define mono_domain_jit_code_hash_lock(domain) EnterCriticalSection(&(domain)->jit_code_hash_lock) -#define mono_domain_jit_code_hash_unlock(domain) LeaveCriticalSection(&(domain)->jit_code_hash_lock) +#define mono_domain_lock(domain) mono_locks_acquire(&(domain)->lock, DomainLock) +#define mono_domain_unlock(domain) mono_locks_release(&(domain)->lock, DomainLock) +#define mono_domain_assemblies_lock(domain) mono_locks_acquire(&(domain)->assemblies_lock, DomainAssembliesLock) +#define mono_domain_assemblies_unlock(domain) mono_locks_release(&(domain)->assemblies_lock, DomainAssembliesLock) +#define mono_domain_jit_code_hash_lock(domain) mono_locks_acquire(&(domain)->jit_code_hash_lock, DomainJitCodeHashLock) +#define mono_domain_jit_code_hash_unlock(domain) mono_locks_release(&(domain)->jit_code_hash_lock, DomainJitCodeHashLock) typedef MonoDomain* (*MonoLoadFunc) (const char *filename, const char *runtime_version); @@ -289,9 +400,6 @@ mono_jit_info_set_generic_sharing_context (MonoJitInfo *ji, MonoGenericSharingCo MonoJitInfo* mono_domain_lookup_shared_generic (MonoDomain *domain, MonoMethod *method) MONO_INTERNAL; -void -mono_domain_register_shared_generic (MonoDomain *domain, MonoMethod *method, MonoJitInfo *jit_info) MONO_INTERNAL; - char * mono_make_shadow_copy (const char *filename) MONO_INTERNAL; @@ -304,6 +412,33 @@ mono_domain_alloc (MonoDomain *domain, guint size) MONO_INTERNAL; gpointer mono_domain_alloc0 (MonoDomain *domain, guint size) MONO_INTERNAL; +void* +mono_domain_code_reserve (MonoDomain *domain, int size) MONO_LLVM_INTERNAL; + +void* +mono_domain_code_reserve_align (MonoDomain *domain, int size, int alignment) MONO_INTERNAL; + +void +mono_domain_code_commit (MonoDomain *domain, void *data, int size, int newsize) MONO_INTERNAL; + +void * +nacl_domain_get_code_dest (MonoDomain *domain, void *data) MONO_INTERNAL; + +void +nacl_domain_code_validate (MonoDomain *domain, guint8 **buf_base, int buf_size, guint8 **code_end) MONO_INTERNAL; + +void +mono_domain_code_foreach (MonoDomain *domain, MonoCodeManagerFunc func, void *user_data) MONO_INTERNAL; + +void +mono_domain_unset (void) MONO_INTERNAL; + +void +mono_domain_set_internal_with_options (MonoDomain *domain, gboolean migrate_exception) MONO_INTERNAL; + +MonoTryBlockHoleTableJitInfo* +mono_jit_info_get_try_block_hole_table_info (MonoJitInfo *ji) MONO_INTERNAL; + /* * Installs a new function which is used to return a MonoJitInfo for a method inside * an AOT module. @@ -416,9 +551,6 @@ mono_runtime_get_no_exec (void) MONO_INTERNAL; gboolean mono_assembly_name_parse (const char *name, MonoAssemblyName *aname) MONO_INTERNAL; -void -mono_assembly_name_free (MonoAssemblyName *aname) MONO_INTERNAL; - MonoImage *mono_assembly_open_from_bundle (const char *filename, MonoImageOpenStatus *status, gboolean refonly) MONO_INTERNAL; @@ -438,4 +570,8 @@ void mono_set_private_bin_path_from_config (MonoDomain *domain) MONO_INTERNAL; int mono_framework_version (void) MONO_INTERNAL; +void mono_reflection_cleanup_domain (MonoDomain *domain) MONO_INTERNAL; + +void mono_assembly_cleanup_domain_bindings (guint32 domain_id) MONO_INTERNAL;; + #endif /* __MONO_METADATA_DOMAIN_INTERNALS_H__ */