#include "marshal.h"
#include "coree.h"
#include <mono/io-layer/io-layer.h>
-#include <mono/utils/mono-logger.h>
+#include <mono/utils/mono-logger-internal.h>
#include <mono/utils/mono-path.h>
#include <mono/utils/mono-mmap.h>
#include <mono/utils/mono-io-portability.h>
#include <mono/metadata/object-internals.h>
#include <mono/metadata/security-core-clr.h>
#include <mono/metadata/verify-internals.h>
+#include <mono/metadata/verify.h>
#include <sys/types.h>
#include <sys/stat.h>
#ifdef HAVE_UNISTD_H
static gboolean mutex_inited;
static CRITICAL_SECTION images_mutex;
+typedef struct ImageUnloadHook ImageUnloadHook;
+struct ImageUnloadHook {
+ MonoImageUnloadFunc func;
+ gpointer user_data;
+};
+
+GSList *image_unload_hooks;
+
+void
+mono_install_image_unload_hook (MonoImageUnloadFunc func, gpointer user_data)
+{
+ ImageUnloadHook *hook;
+
+ g_return_if_fail (func != NULL);
+
+ hook = g_new0 (ImageUnloadHook, 1);
+ hook->func = func;
+ hook->user_data = user_data;
+ image_unload_hooks = g_slist_prepend (image_unload_hooks, hook);
+}
+
+void
+mono_remove_image_unload_hook (MonoImageUnloadFunc func, gpointer user_data)
+{
+ GSList *l;
+ ImageUnloadHook *hook;
+
+ for (l = image_unload_hooks; l; l = l->next) {
+ hook = l->data;
+
+ if (hook->func == func && hook->user_data == user_data) {
+ g_free (hook);
+ image_unload_hooks = g_slist_delete_link (image_unload_hooks, l);
+ break;
+ }
+ }
+}
+
+static void
+mono_image_invoke_unload_hook (MonoImage *image)
+{
+ GSList *l;
+ ImageUnloadHook *hook;
+
+ for (l = image_unload_hooks; l; l = l->next) {
+ hook = l->data;
+
+ hook->func (image, hook->user_data);
+ }
+}
+
/* returns offset relative to image->raw_data */
guint32
mono_cli_rva_image_map (MonoImage *image, guint32 addr)
void
mono_images_cleanup (void)
{
+ GHashTableIter iter;
+ MonoImage *image;
+
DeleteCriticalSection (&images_mutex);
+ g_hash_table_iter_init (&iter, loaded_images_hash);
+ while (g_hash_table_iter_next (&iter, NULL, (void**)&image))
+ mono_trace (G_LOG_LEVEL_INFO, MONO_TRACE_ASSEMBLY, "Assembly image '%s' still loaded at shutdown.", image->name);
+
g_hash_table_destroy (loaded_images_hash);
g_hash_table_destroy (loaded_images_refonly_hash);
MonoTableInfo *t, *mt;
t = &image->tables [MONO_TABLE_TYPEDEF];
mt = &image->tables [MONO_TABLE_METHOD];
- if (mono_framework_version () == 1) {
- image->checked_module_cctor = TRUE;
- return;
- }
if (image->dynamic) {
/* FIXME: */
image->checked_module_cctor = TRUE;
GList *list_iter, *valid_modules = NULL;
MonoImageOpenStatus status;
- if ((image->module_count == 0) || (idx > image->module_count))
+ if ((image->module_count == 0) || (idx > image->module_count || idx <= 0))
return NULL;
if (image->modules_loaded [idx - 1])
return image->modules [idx - 1];
{
MonoCLIImageInfo *iinfo;
MonoDotNetHeader *header;
+ GSList *errors = NULL;
mono_profiler_module_event (image, MONO_PROFILE_START_LOAD);
if (care_about_pecoff == FALSE)
goto done;
- if (!mono_verifier_verify_pe_data (image, NULL))
+ if (!mono_verifier_verify_pe_data (image, &errors))
goto invalid_image;
if (!mono_image_load_pe_data (image))
goto done;
}
- if (!mono_verifier_verify_cli_data (image, NULL))
+ if (!mono_verifier_verify_cli_data (image, &errors))
goto invalid_image;
if (!mono_image_load_cli_data (image))
goto invalid_image;
- if (!mono_verifier_verify_table_data (image, NULL))
+ if (!mono_verifier_verify_table_data (image, &errors))
goto invalid_image;
mono_image_load_names (image);
return image;
invalid_image:
+ if (errors) {
+ MonoVerifyInfo *info = errors->data;
+ g_warning ("Could not load image %s due to %s", image->name, info->message);
+ mono_free_verify_list (errors);
+ }
mono_profiler_module_loaded (image, MONO_PROFILE_FAILED);
mono_image_close (image);
- return NULL;
+ return NULL;
}
static MonoImage *
image->raw_buffer_used = TRUE;
image->raw_data_len = mono_file_map_size (filed);
image->raw_data = mono_file_map (image->raw_data_len, MONO_MMAP_READ|MONO_MMAP_PRIVATE, mono_file_map_fd (filed), 0, &image->raw_data_handle);
+#if defined(HAVE_MMAP) && !defined (HOST_WIN32)
+ if (!image->raw_data) {
+ image->fileio_used = TRUE;
+ image->raw_data = mono_file_map_fileio (image->raw_data_len, MONO_MMAP_READ|MONO_MMAP_PRIVATE, mono_file_map_fd (filed), 0, &image->raw_data_handle);
+ }
+#endif
if (!image->raw_data) {
mono_file_map_close (filed);
g_free (image);
}
MonoImage *
-mono_image_open_from_data_full (char *data, guint32 data_len, gboolean need_copy, MonoImageOpenStatus *status, gboolean refonly)
+mono_image_open_from_data_with_name (char *data, guint32 data_len, gboolean need_copy, MonoImageOpenStatus *status, gboolean refonly, const char *name)
{
MonoCLIImageInfo *iinfo;
MonoImage *image;
image->raw_data = datac;
image->raw_data_len = data_len;
image->raw_data_allocated = need_copy;
- image->name = g_strdup_printf ("data-%p", datac);
+ image->name = (name == NULL) ? g_strdup_printf ("data-%p", datac) : g_strdup(name);
iinfo = g_new0 (MonoCLIImageInfo, 1);
image->image_info = iinfo;
image->ref_only = refonly;
return register_image (image);
}
+MonoImage *
+mono_image_open_from_data_full (char *data, guint32 data_len, gboolean need_copy, MonoImageOpenStatus *status, gboolean refonly)
+{
+ return mono_image_open_from_data_with_name (data, data_len, need_copy, status, refonly, NULL);
+}
+
MonoImage *
mono_image_open_from_data (char *data, guint32 data_len, gboolean need_copy, MonoImageOpenStatus *status)
{
if (status) {
if (last_error == ERROR_BAD_EXE_FORMAT || last_error == STATUS_INVALID_IMAGE_FORMAT)
*status = MONO_IMAGE_IMAGE_INVALID;
- else
- *status = MONO_IMAGE_ERROR_ERRNO;
+ else {
+ if (last_error == ERROR_FILE_NOT_FOUND || last_error == ERROR_PATH_NOT_FOUND)
+ errno = ENOENT;
+ else
+ errno = 0;
+ }
}
return NULL;
}
}
*/
-static void
-free_remoting_wrappers (gpointer key, gpointer val, gpointer user_data)
-{
- g_free (val);
-}
-
static void
free_array_cache_entry (gpointer key, gpointer val, gpointer user_data)
{
MonoImage *image2;
GHashTable *loaded_images;
int i;
+ GSList *free_list;
g_return_val_if_fail (image != NULL, FALSE);
mono_trace (G_LOG_LEVEL_INFO, MONO_TRACE_ASSEMBLY, "Unloading image %s [%p].", image->name, image);
- mono_metadata_clean_for_image (image);
+ mono_image_invoke_unload_hook (image);
+
+ free_list = mono_metadata_clean_for_image (image);
/*
* The caches inside a MonoImage might refer to metadata which is stored in referenced
int i;
for (i = 0; i < t->rows; i++) {
- if (image->references [i]) {
+ if (image->references [i] && image->references [i] != REFERENCE_MISSING) {
if (!mono_assembly_close_except_image_pools (image->references [i]))
image->references [i] = NULL;
}
#endif
if (image->raw_buffer_used) {
- if (image->raw_data != NULL)
- mono_file_unmap (image->raw_data, image->raw_data_handle);
+ if (image->raw_data != NULL) {
+#ifndef HOST_WIN32
+ if (image->fileio_used)
+ mono_file_unmap_fileio (image->raw_data, image->raw_data_handle);
+ else
+#endif
+ mono_file_unmap (image->raw_data, image->raw_data_handle);
+ }
}
if (image->raw_data_allocated) {
free_hash (image->delegate_end_invoke_cache);
free_hash (image->delegate_invoke_cache);
free_hash (image->delegate_abstract_invoke_cache);
- if (image->remoting_invoke_cache)
- g_hash_table_foreach (image->remoting_invoke_cache, free_remoting_wrappers, NULL);
+ free_hash (image->delegate_bound_static_invoke_cache);
free_hash (image->remoting_invoke_cache);
free_hash (image->runtime_invoke_cache);
free_hash (image->runtime_invoke_direct_cache);
free_hash (image->castclass_cache);
free_hash (image->proxy_isinst_cache);
free_hash (image->thunk_invoke_cache);
+ free_hash (image->var_cache_slow);
+ free_hash (image->mvar_cache_slow);
+ free_hash (image->wrapper_param_names);
+ free_hash (image->native_wrapper_aot_cache);
+ free_hash (image->pinvoke_scopes);
+ free_hash (image->pinvoke_scope_filenames);
/* The ownership of signatures is not well defined */
//g_hash_table_foreach (image->memberref_signatures, free_mr_signatures, NULL);
g_hash_table_destroy (image->helper_signatures);
g_hash_table_destroy (image->method_signatures);
- if (image->generic_class_cache)
- g_hash_table_destroy (image->generic_class_cache);
-
if (image->rgctx_template_hash)
g_hash_table_destroy (image->rgctx_template_hash);
mono_property_hash_destroy (image->property_hash);
g_slist_free (image->reflection_info_unregister_classes);
+ image->reflection_info_unregister_classes = free_list;
if (image->interface_bitset) {
mono_unload_interface_ids (image->interface_bitset);
mono_image_close_finish (MonoImage *image)
{
int i;
+ GSList *l;
+
+ for (l = image->reflection_info_unregister_classes; l; l = l->next)
+ g_free (l->data);
+ g_slist_free (image->reflection_info_unregister_classes);
+ image->reflection_info_unregister_classes = NULL;
if (image->references && !image->dynamic) {
MonoTableInfo *t = &image->tables [MONO_TABLE_ASSEMBLYREF];
int i;
for (i = 0; i < t->rows; i++) {
- if (image->references [i])
+ if (image->references [i] && image->references [i] != REFERENCE_MISSING)
mono_assembly_close_finish (image->references [i]);
}