From 45287ed696a4bea906cc15a4bc870960a4b0e623 Mon Sep 17 00:00:00 2001 From: =?utf8?q?Aleksey=20Kliger=20=28=CE=BBgeek=29?= Date: Sun, 7 Feb 2021 12:08:01 -0500 Subject: [PATCH] Remove MONO_ASMCTX_REFONLY (#47966) * remove MONO_ASMCTX_REFONLY * Also remove mono_image_open_from_data_internal refonly arg --- src/mono/mono/metadata/appdomain.c | 15 ++-- src/mono/mono/metadata/assembly.c | 79 +++++++++++++--------- src/mono/mono/metadata/class.c | 2 - src/mono/mono/metadata/debug-mono-ppdb.c | 2 +- src/mono/mono/metadata/domain-internals.h | 1 - src/mono/mono/metadata/domain.c | 7 +- src/mono/mono/metadata/icall.c | 20 +----- src/mono/mono/metadata/image.c | 24 +++++-- src/mono/mono/metadata/metadata-internals.h | 12 ++-- src/mono/mono/metadata/metadata-update.c | 2 +- src/mono/mono/mini/aot-runtime.c | 2 +- .../mono/tests/metadata-verifier/gen-md-tests.c | 2 +- 12 files changed, 87 insertions(+), 81 deletions(-) diff --git a/src/mono/mono/metadata/appdomain.c b/src/mono/mono/metadata/appdomain.c index 65aed1c..9b19949 100644 --- a/src/mono/mono/metadata/appdomain.c +++ b/src/mono/mono/metadata/appdomain.c @@ -1088,6 +1088,7 @@ mono_domain_assembly_preload (MonoAssemblyLoadContext *alc, g_assert (alc); g_assert (domain == mono_domain_get ()); + g_assert (!refonly); MonoAssemblyCandidatePredicate predicate = NULL; void* predicate_ud = NULL; @@ -1096,7 +1097,7 @@ mono_domain_assembly_preload (MonoAssemblyLoadContext *alc, predicate_ud = aname; } MonoAssemblyOpenRequest req; - mono_assembly_request_prepare_open (&req, refonly ? MONO_ASMCTX_REFONLY : MONO_ASMCTX_DEFAULT, alc); + mono_assembly_request_prepare_open (&req, MONO_ASMCTX_DEFAULT, alc); req.request.predicate = predicate; req.request.predicate_ud = predicate_ud; @@ -1245,7 +1246,7 @@ mono_alc_load_file (MonoAssemblyLoadContext *alc, MonoStringHandle fname, MonoAs if (status == MONO_IMAGE_IMAGE_INVALID) mono_error_set_bad_image_by_name (error, filename, "Invalid Image: %s", filename); else - mono_error_set_simple_file_not_found (error, filename, asmctx == MONO_ASMCTX_REFONLY); + mono_error_set_simple_file_not_found (error, filename, FALSE); } leave: @@ -1272,7 +1273,7 @@ leave: } static MonoAssembly* -mono_alc_load_raw_bytes (MonoAssemblyLoadContext *alc, guint8 *raw_assembly, guint32 raw_assembly_len, guint8 *raw_symbol_data, guint32 raw_symbol_len, gboolean refonly, MonoError *error); +mono_alc_load_raw_bytes (MonoAssemblyLoadContext *alc, guint8 *raw_assembly, guint32 raw_assembly_len, guint8 *raw_symbol_data, guint32 raw_symbol_len, MonoError *error); MonoReflectionAssemblyHandle ves_icall_System_Runtime_Loader_AssemblyLoadContext_InternalLoadFromStream (gpointer native_alc, gpointer raw_assembly_ptr, gint32 raw_assembly_len, gpointer raw_symbols_ptr, gint32 raw_symbols_len, MonoError *error) @@ -1281,7 +1282,7 @@ ves_icall_System_Runtime_Loader_AssemblyLoadContext_InternalLoadFromStream (gpoi MonoDomain *domain = mono_alc_domain (alc); MonoReflectionAssemblyHandle result = MONO_HANDLE_CAST (MonoReflectionAssembly, NULL_HANDLE); MonoAssembly *assm = NULL; - assm = mono_alc_load_raw_bytes (alc, (guint8 *)raw_assembly_ptr, raw_assembly_len, (guint8 *)raw_symbols_ptr, raw_symbols_len, FALSE, error); + assm = mono_alc_load_raw_bytes (alc, (guint8 *)raw_assembly_ptr, raw_assembly_len, (guint8 *)raw_symbols_ptr, raw_symbols_len, error); goto_if_nok (error, leave); result = mono_assembly_get_object_handle (domain, assm, error); @@ -1291,11 +1292,11 @@ leave: } static MonoAssembly* -mono_alc_load_raw_bytes (MonoAssemblyLoadContext *alc, guint8 *assembly_data, guint32 raw_assembly_len, guint8 *raw_symbol_data, guint32 raw_symbol_len, gboolean refonly, MonoError *error) +mono_alc_load_raw_bytes (MonoAssemblyLoadContext *alc, guint8 *assembly_data, guint32 raw_assembly_len, guint8 *raw_symbol_data, guint32 raw_symbol_len, MonoError *error) { MonoAssembly *ass = NULL; MonoImageOpenStatus status; - MonoImage *image = mono_image_open_from_data_internal (alc, (char*)assembly_data, raw_assembly_len, TRUE, NULL, refonly, FALSE, NULL, NULL); + MonoImage *image = mono_image_open_from_data_internal (alc, (char*)assembly_data, raw_assembly_len, TRUE, NULL, FALSE, NULL, NULL); if (!image) { mono_error_set_bad_image_by_name (error, "In memory assembly", "0x%p", assembly_data); @@ -1306,7 +1307,7 @@ mono_alc_load_raw_bytes (MonoAssemblyLoadContext *alc, guint8 *assembly_data, gu mono_debug_open_image_from_memory (image, raw_symbol_data, raw_symbol_len); MonoAssemblyLoadRequest req; - mono_assembly_request_prepare_load (&req, refonly? MONO_ASMCTX_REFONLY : MONO_ASMCTX_INDIVIDUAL, alc); + mono_assembly_request_prepare_load (&req, MONO_ASMCTX_INDIVIDUAL, alc); ass = mono_assembly_request_load_from (image, "", &req, &status); if (!ass) { diff --git a/src/mono/mono/metadata/assembly.c b/src/mono/mono/metadata/assembly.c index bfe44a7..2f0a928 100644 --- a/src/mono/mono/metadata/assembly.c +++ b/src/mono/mono/metadata/assembly.c @@ -97,7 +97,7 @@ static const MonoBundledSatelliteAssembly **satellite_bundles; /* Class lazy loading functions */ static GENERATE_TRY_GET_CLASS_WITH_CACHE (internals_visible, "System.Runtime.CompilerServices", "InternalsVisibleToAttribute") static MonoAssembly* -mono_assembly_invoke_search_hook_internal (MonoAssemblyLoadContext *alc, MonoAssembly *requesting, MonoAssemblyName *aname, gboolean refonly, gboolean postload); +mono_assembly_invoke_search_hook_internal (MonoAssemblyLoadContext *alc, MonoAssembly *requesting, MonoAssemblyName *aname, gboolean postload); static MonoAssembly * invoke_assembly_preload_hook (MonoAssemblyLoadContext *alc, MonoAssemblyName *aname, gchar **apath); @@ -1015,10 +1015,10 @@ search_bundle_for_assembly (MonoAssemblyLoadContext *alc, MonoAssemblyName *anam MonoImageOpenStatus status; MonoImage *image; MonoAssemblyLoadRequest req; - image = mono_assembly_open_from_bundle (alc, aname->name, &status, FALSE, aname->culture); + image = mono_assembly_open_from_bundle (alc, aname->name, &status, aname->culture); if (!image && !g_str_has_suffix (aname->name, ".dll")) { char *name = g_strdup_printf ("%s.dll", aname->name); - image = mono_assembly_open_from_bundle (alc, name, &status, FALSE, aname->culture); + image = mono_assembly_open_from_bundle (alc, name, &status, aname->culture); } if (image) { mono_assembly_request_prepare_load (&req, MONO_ASMCTX_DEFAULT, alc); @@ -1147,7 +1147,7 @@ netcore_load_reference (MonoAssemblyName *aname, MonoAssemblyLoadContext *alc, M // Looking up corlib resources here can cause an infinite loop // See: https://github.com/dotnet/coreclr/blob/0a762eb2f3a299489c459da1ddeb69e042008f07/src/vm/appdomain.cpp#L5178-L5239 if (!(strcmp (aname->name, MONO_ASSEMBLY_CORLIB_RESOURCE_NAME) == 0 && is_satellite) && postload) { - reference = mono_assembly_invoke_search_hook_internal (alc, requesting, aname, FALSE, TRUE); + reference = mono_assembly_invoke_search_hook_internal (alc, requesting, aname, TRUE); if (reference) { mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_ASSEMBLY, "Assembly found with AssemblyResolve event: '%s'.", aname->name); goto leave; @@ -1159,7 +1159,7 @@ leave: } static MonoImage * -open_from_satellite_bundle (MonoAssemblyLoadContext *alc, const char *filename, MonoImageOpenStatus *status, gboolean refonly, const char *culture) +open_from_satellite_bundle (MonoAssemblyLoadContext *alc, const char *filename, MonoImageOpenStatus *status, const char *culture) { if (!satellite_bundles) return NULL; @@ -1168,7 +1168,7 @@ open_from_satellite_bundle (MonoAssemblyLoadContext *alc, const char *filename, char *name = g_strdup (filename); for (int i = 0; !image && satellite_bundles [i]; ++i) { if (strcmp (satellite_bundles [i]->name, name) == 0 && strcmp (satellite_bundles [i]->culture, culture) == 0) { - image = mono_image_open_from_data_internal (alc, (char *)satellite_bundles [i]->data, satellite_bundles [i]->size, FALSE, status, refonly, FALSE, name, NULL); + image = mono_image_open_from_data_internal (alc, (char *)satellite_bundles [i]->data, satellite_bundles [i]->size, FALSE, status, FALSE, name, NULL); break; } } @@ -1475,19 +1475,19 @@ struct AssemblySearchHook { static AssemblySearchHook *assembly_search_hook = NULL; static MonoAssembly* -mono_assembly_invoke_search_hook_internal (MonoAssemblyLoadContext *alc, MonoAssembly *requesting, MonoAssemblyName *aname, gboolean refonly, gboolean postload) +mono_assembly_invoke_search_hook_internal (MonoAssemblyLoadContext *alc, MonoAssembly *requesting, MonoAssemblyName *aname, gboolean postload) { AssemblySearchHook *hook; for (hook = assembly_search_hook; hook; hook = hook->next) { - if ((hook->refonly == refonly) && (hook->postload == postload)) { + if ((hook->refonly == FALSE) && (hook->postload == postload)) { MonoAssembly *ass; if (hook->version == 1) { ass = hook->func.v1 (aname, hook->user_data); } else { ERROR_DECL (hook_error); g_assert (hook->version == 2); - ass = hook->func.v2 (alc, requesting, aname, refonly, postload, hook->user_data, hook_error); + ass = hook->func.v2 (alc, requesting, aname, FALSE, postload, hook->user_data, hook_error); mono_error_assert_ok (hook_error); /* FIXME: proper error handling */ } if (ass) @@ -1504,7 +1504,7 @@ mono_assembly_invoke_search_hook_internal (MonoAssemblyLoadContext *alc, MonoAss MonoAssembly* mono_assembly_invoke_search_hook (MonoAssemblyName *aname) { - return mono_assembly_invoke_search_hook_internal (NULL, NULL, aname, FALSE, FALSE); + return mono_assembly_invoke_search_hook_internal (NULL, NULL, aname, FALSE); } static void @@ -1870,7 +1870,7 @@ absolute_dir (const gchar *filename) } static MonoImage * -open_from_bundle_internal (MonoAssemblyLoadContext *alc, const char *filename, MonoImageOpenStatus *status, gboolean refonly, gboolean is_satellite) +open_from_bundle_internal (MonoAssemblyLoadContext *alc, const char *filename, MonoImageOpenStatus *status, gboolean is_satellite) { if (!bundles) return NULL; @@ -1880,7 +1880,7 @@ open_from_bundle_internal (MonoAssemblyLoadContext *alc, const char *filename, M for (int i = 0; !image && bundles [i]; ++i) { if (strcmp (bundles [i]->name, name) == 0) { // Since bundled images don't exist on disk, don't give them a legit filename - image = mono_image_open_from_data_internal (alc, (char*)bundles [i]->data, bundles [i]->size, FALSE, status, refonly, FALSE, name, NULL); + image = mono_image_open_from_data_internal (alc, (char*)bundles [i]->data, bundles [i]->size, FALSE, status, FALSE, name, NULL); break; } } @@ -1899,7 +1899,7 @@ open_from_bundle_internal (MonoAssemblyLoadContext *alc, const char *filename, M * returns NULL */ MonoImage * -mono_assembly_open_from_bundle (MonoAssemblyLoadContext *alc, const char *filename, MonoImageOpenStatus *status, gboolean refonly, const char *culture) +mono_assembly_open_from_bundle (MonoAssemblyLoadContext *alc, const char *filename, MonoImageOpenStatus *status, const char *culture) { /* * we do a very simple search for bundled assemblies: it's not a general @@ -1909,9 +1909,9 @@ mono_assembly_open_from_bundle (MonoAssemblyLoadContext *alc, const char *filena gboolean is_satellite = culture && culture [0] != 0; if (is_satellite) - image = open_from_satellite_bundle (alc, filename, status, refonly, culture); + image = open_from_satellite_bundle (alc, filename, status, culture); else - image = open_from_bundle_internal (alc, filename, status, refonly, FALSE); + image = open_from_bundle_internal (alc, filename, status, FALSE); if (image) { mono_image_addref (image); @@ -1948,11 +1948,16 @@ mono_assembly_open_from_bundle (MonoAssemblyLoadContext *alc, const char *filena MonoAssembly * mono_assembly_open_full (const char *filename, MonoImageOpenStatus *status, gboolean refonly) { + if (refonly) { + if (status) + *status = MONO_IMAGE_IMAGE_INVALID; + return NULL; + } MonoAssembly *res; MONO_ENTER_GC_UNSAFE; MonoAssemblyOpenRequest req; mono_assembly_request_prepare_open (&req, - refonly ? MONO_ASMCTX_REFONLY : MONO_ASMCTX_DEFAULT, + MONO_ASMCTX_DEFAULT, mono_domain_default_alc (mono_domain_get ())); res = mono_assembly_request_open (filename, &req, status); MONO_EXIT_GC_UNSAFE; @@ -2038,7 +2043,7 @@ mono_assembly_request_open (const char *filename, const MonoAssemblyOpenRequest return NULL; } - if (load_req.asmctx != MONO_ASMCTX_REFONLY) { + { MonoAssemblyContextKind out_asmctx; /* If the path belongs to the appdomain base dir or the * base dir of the requesting assembly, load the @@ -2048,10 +2053,8 @@ mono_assembly_request_open (const char *filename, const MonoAssemblyOpenRequest load_req.asmctx = out_asmctx; } } else { - if (load_req.asmctx != MONO_ASMCTX_REFONLY) { - /* GAC assemblies always in default context or refonly context. */ - load_req.asmctx = MONO_ASMCTX_DEFAULT; - } + /* GAC assemblies always in default context or refonly context. */ + load_req.asmctx = MONO_ASMCTX_DEFAULT; } if (new_fname && new_fname != fname) { g_free (fname); @@ -2062,24 +2065,23 @@ mono_assembly_request_open (const char *filename, const MonoAssemblyOpenRequest image = NULL; - const gboolean refonly = load_req.asmctx == MONO_ASMCTX_REFONLY; /* for LoadFrom(string), LoadFile(string) and Load(byte[]), allow them * to load problematic images. Not sure if ReflectionOnlyLoad(string) * and ReflectionOnlyLoadFrom(string) should also be allowed - let's * say, yes. */ - const gboolean load_from_context = load_req.asmctx == MONO_ASMCTX_LOADFROM || load_req.asmctx == MONO_ASMCTX_INDIVIDUAL || load_req.asmctx == MONO_ASMCTX_REFONLY; + const gboolean load_from_context = load_req.asmctx == MONO_ASMCTX_LOADFROM || load_req.asmctx == MONO_ASMCTX_INDIVIDUAL; // If VM built with mkbundle loaded_from_bundle = FALSE; if (bundles != NULL || satellite_bundles != NULL) { /* We don't know the culture of the filename we're loading here, so this call is not culture aware. */ - image = mono_assembly_open_from_bundle (load_req.alc, fname, status, refonly, NULL); + image = mono_assembly_open_from_bundle (load_req.alc, fname, status, NULL); loaded_from_bundle = image != NULL; } if (!image) - image = mono_image_open_a_lot (load_req.alc, fname, status, refonly, load_from_context); + image = mono_image_open_a_lot (load_req.alc, fname, status, FALSE, load_from_context); if (!image){ if (*status == MONO_IMAGE_OK) @@ -2326,13 +2328,18 @@ MonoAssembly * mono_assembly_load_from_full (MonoImage *image, const char*fname, MonoImageOpenStatus *status, gboolean refonly) { + if (refonly) { + if (status) + *status = MONO_IMAGE_IMAGE_INVALID; + return NULL; + } MonoAssembly *res; MONO_ENTER_GC_UNSAFE; MonoAssemblyLoadRequest req; MonoImageOpenStatus def_status; if (!status) status = &def_status; - mono_assembly_request_prepare_load (&req, refonly ? MONO_ASMCTX_REFONLY : MONO_ASMCTX_DEFAULT, mono_domain_default_alc (mono_domain_get ())); + mono_assembly_request_prepare_load (&req, MONO_ASMCTX_DEFAULT, mono_domain_default_alc (mono_domain_get ())); res = mono_assembly_request_load_from (image, fname, &req, status); MONO_EXIT_GC_UNSAFE; return res; @@ -2412,7 +2419,7 @@ mono_assembly_request_load_from (MonoImage *image, const char *fname, */ if (ass->aname.name && asmctx != MONO_ASMCTX_INDIVIDUAL) { /* FIXME: I think individual context should probably also look for an existing MonoAssembly here, we just need to pass the asmctx to the search hook so that it does a filename match (I guess?) */ - ass2 = mono_assembly_invoke_search_hook_internal (req->alc, NULL, &ass->aname, asmctx == MONO_ASMCTX_REFONLY, FALSE); + ass2 = mono_assembly_invoke_search_hook_internal (req->alc, NULL, &ass->aname, FALSE); if (ass2) { mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_ASSEMBLY, "Image %s[%p] reusing existing assembly %s[%p]", ass->aname.name, ass, ass2->aname.name, ass2); g_free (ass); @@ -2430,7 +2437,7 @@ mono_assembly_request_load_from (MonoImage *image, const char *fname, * this image and we won't be able to look for a different * candidate. */ - if (asmctx != MONO_ASMCTX_REFONLY) { + { ERROR_DECL (refasm_error); if (mono_assembly_has_reference_assembly_attribute (ass, refasm_error)) { mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_ASSEMBLY, "Image for assembly '%s' (%s) has ReferenceAssemblyAttribute, skipping", ass->aname.name, image->name); @@ -3256,12 +3263,17 @@ mono_assembly_load_full_alc (MonoGCHandle alc_gchandle, MonoAssemblyName *aname, MonoAssembly* mono_assembly_load_full (MonoAssemblyName *aname, const char *basedir, MonoImageOpenStatus *status, gboolean refonly) { + if (refonly) { + if (status) + *status = MONO_IMAGE_IMAGE_INVALID; + return NULL; + } MonoAssembly *res; MONO_ENTER_GC_UNSAFE; MonoAssemblyByNameRequest req; mono_assembly_request_prepare_byname (&req, - refonly ? MONO_ASMCTX_REFONLY : MONO_ASMCTX_DEFAULT, - mono_domain_default_alc (mono_domain_get ())); + MONO_ASMCTX_DEFAULT, + mono_domain_default_alc (mono_domain_get ())); req.requesting_assembly = NULL; req.basedir = basedir; res = mono_assembly_request_byname (aname, &req, status); @@ -3303,6 +3315,8 @@ mono_assembly_load (MonoAssemblyName *aname, const char *basedir, MonoImageOpenS MonoAssembly* mono_assembly_loaded_full (MonoAssemblyName *aname, gboolean refonly) { + if (refonly) + return NULL; MonoAssemblyLoadContext *alc = mono_domain_default_alc (mono_domain_get ()); return mono_assembly_loaded_internal (alc, aname, refonly); } @@ -3313,9 +3327,11 @@ mono_assembly_loaded_internal (MonoAssemblyLoadContext *alc, MonoAssemblyName *a MonoAssembly *res; MonoAssemblyName mapped_aname; + g_assert (!refonly); + aname = mono_assembly_remap_version (aname, &mapped_aname); - res = mono_assembly_invoke_search_hook_internal (alc, NULL, aname, refonly, FALSE); + res = mono_assembly_invoke_search_hook_internal (alc, NULL, aname, FALSE); return res; } @@ -3744,7 +3760,6 @@ mono_asmctx_get_name (const MonoAssemblyContext *asmctx) { static const char* names [] = { "DEFAULT", - "REFONLY", "LOADFROM", "INDIVIDIUAL", "INTERNAL" diff --git a/src/mono/mono/metadata/class.c b/src/mono/mono/metadata/class.c index 8dee389..540e55a 100644 --- a/src/mono/mono/metadata/class.c +++ b/src/mono/mono/metadata/class.c @@ -215,8 +215,6 @@ mono_class_from_typeref_checked (MonoImage *image, guint32 type_token, MonoError mono_assembly_get_assemblyref (image, idx - 1, &aname); human_name = mono_stringify_assembly_name (&aname); gboolean refonly = FALSE; - if (image->assembly) - refonly = mono_asmctx_get_kind (&image->assembly->context) == MONO_ASMCTX_REFONLY; mono_error_set_simple_file_not_found (error, human_name, refonly); g_free (human_name); return NULL; diff --git a/src/mono/mono/metadata/debug-mono-ppdb.c b/src/mono/mono/metadata/debug-mono-ppdb.c index b7dc9ce..b4b42fa 100644 --- a/src/mono/mono/metadata/debug-mono-ppdb.c +++ b/src/mono/mono/metadata/debug-mono-ppdb.c @@ -198,7 +198,7 @@ mono_ppdb_load_file (MonoImage *image, const guint8 *raw_contents, int size) MonoAssemblyLoadContext *alc = mono_image_get_alc (image); if (raw_contents) { if (size > 4 && strncmp ((char*)raw_contents, "BSJB", 4) == 0) - ppdb_image = mono_image_open_from_data_internal (alc, (char*)raw_contents, size, TRUE, &status, FALSE, TRUE, NULL, NULL); + ppdb_image = mono_image_open_from_data_internal (alc, (char*)raw_contents, size, TRUE, &status, TRUE, NULL, NULL); } else { /* ppdb files drop the .exe/.dll extension */ filename = mono_image_get_filename (image); diff --git a/src/mono/mono/metadata/domain-internals.h b/src/mono/mono/metadata/domain-internals.h index e2d77e8..06e15d7 100644 --- a/src/mono/mono/metadata/domain-internals.h +++ b/src/mono/mono/metadata/domain-internals.h @@ -547,7 +547,6 @@ mono_domain_assembly_open_internal (MonoDomain *domain, MonoAssemblyLoadContext MonoImage *mono_assembly_open_from_bundle (MonoAssemblyLoadContext *alc, const char *filename, MonoImageOpenStatus *status, - gboolean refonly, const char *culture); MonoAssembly * diff --git a/src/mono/mono/metadata/domain.c b/src/mono/mono/metadata/domain.c index ab51bc7..8cdd233 100644 --- a/src/mono/mono/metadata/domain.c +++ b/src/mono/mono/metadata/domain.c @@ -549,7 +549,7 @@ mono_init_internal (const char *filename, const char *exe_filename, const char * runtimes = get_runtimes_from_exe (exe_filename, &exe_image); #ifdef HOST_WIN32 if (!exe_image) { - exe_image = mono_assembly_open_from_bundle (mono_domain_default_alc (domain), exe_filename, NULL, FALSE, NULL); + exe_image = mono_assembly_open_from_bundle (mono_domain_default_alc (domain), exe_filename, NULL, NULL); if (!exe_image) exe_image = mono_image_open (exe_filename, NULL); } @@ -1599,7 +1599,7 @@ get_runtimes_from_exe (const char *file, MonoImage **out_image) } /* Look for a runtime with the exact version */ - image = mono_assembly_open_from_bundle (mono_domain_default_alc (mono_domain_get ()), file, NULL, FALSE, NULL); + image = mono_assembly_open_from_bundle (mono_domain_default_alc (mono_domain_get ()), file, NULL, NULL); if (image == NULL) image = mono_image_open (file, NULL); @@ -1663,8 +1663,7 @@ mono_domain_get_assemblies (MonoDomain *domain, gboolean refonly) mono_domain_assemblies_lock (domain); for (tmp = domain->domain_assemblies; tmp; tmp = tmp->next) { ass = (MonoAssembly *)tmp->data; - gboolean ass_ref_only = mono_asmctx_get_kind (&ass->context) == MONO_ASMCTX_REFONLY; - if (refonly != ass_ref_only) + if (refonly != FALSE) continue; g_ptr_array_add (assemblies, ass); } diff --git a/src/mono/mono/metadata/icall.c b/src/mono/mono/metadata/icall.c index e2e7484..a0c6c0a 100644 --- a/src/mono/mono/metadata/icall.c +++ b/src/mono/mono/metadata/icall.c @@ -2115,20 +2115,14 @@ MonoObjectHandle ves_icall_RuntimeFieldInfo_GetValueInternal (MonoReflectionFieldHandle field_handle, MonoObjectHandle obj_handle, MonoError *error) { MonoReflectionField * const field = MONO_HANDLE_RAW (field_handle); - MonoClass *fklass = field->klass; MonoClassField *cf = field->field; - if (mono_asmctx_get_kind (&m_class_get_image (fklass)->assembly->context) == MONO_ASMCTX_REFONLY) { - mono_error_set_invalid_operation (error, - "It is illegal to get the value on a field on a type loaded using the ReflectionOnly methods."); - return NULL_HANDLE; - } - MonoObject * const obj = MONO_HANDLE_RAW (obj_handle); MonoObject *result; #ifndef DISABLE_REMOTING if (G_UNLIKELY (obj != NULL && mono_class_is_transparent_proxy (mono_object_class (obj)))) { + MonoClass *fklass = field->klass; /* We get here if someone used a * System.Reflection.FieldInfo:GetValue on a * ContextBoundObject's or cross-domain MarshalByRefObject's @@ -2146,14 +2140,10 @@ ves_icall_RuntimeFieldInfo_SetValueInternal (MonoReflectionFieldHandle field, Mo { MonoClassField *cf = MONO_HANDLE_GETVAL (field, field); - MonoClass *field_klass = MONO_HANDLE_GETVAL (field, klass); - if (mono_asmctx_get_kind (&m_class_get_image (field_klass)->assembly->context) == MONO_ASMCTX_REFONLY) { - mono_error_set_invalid_operation (error, "It is illegal to set the value on a field on a type loaded using the ReflectionOnly methods."); - return; - } #ifndef DISABLE_REMOTING if (G_UNLIKELY (!MONO_HANDLE_IS_NULL (obj) && mono_class_is_transparent_proxy (mono_handle_class (obj)))) { + MonoClass *field_klass = MONO_HANDLE_GETVAL (field, klass); /* We get here if someone used a * System.Reflection.FieldInfo:SetValue on a * ContextBoundObject's or cross-domain MarshalByRefObject's @@ -3544,10 +3534,6 @@ ves_icall_InternalInvoke (MonoReflectionMethodHandle method_handle, MonoObjectHa } image = m_class_get_image (m->klass); - if (mono_asmctx_get_kind (&image->assembly->context) == MONO_ASMCTX_REFONLY) { - exception = mono_get_exception_invalid_operation ("It is illegal to invoke a method on a type loaded using the ReflectionOnly api."); - goto return_null; - } if (m_class_get_rank (m->klass) && !strcmp (m->name, ".ctor")) { int i; @@ -5224,8 +5210,6 @@ add_file_to_modules_array (MonoDomain *domain, MonoArrayHandle dest, int dest_id if (!m) { const char *filename = mono_metadata_string_heap (image, cols [MONO_FILE_NAME]); gboolean refonly = FALSE; - if (image->assembly) - refonly = mono_asmctx_get_kind (&image->assembly->context) == MONO_ASMCTX_REFONLY; mono_error_set_simple_file_not_found (error, filename, refonly); goto leave; } diff --git a/src/mono/mono/metadata/image.c b/src/mono/mono/metadata/image.c index 359c3f8..cb2a585 100644 --- a/src/mono/mono/metadata/image.c +++ b/src/mono/mono/metadata/image.c @@ -1677,7 +1677,7 @@ register_image (MonoLoadedImages *li, MonoImage *image) } MonoImage * -mono_image_open_from_data_internal (MonoAssemblyLoadContext *alc, char *data, guint32 data_len, gboolean need_copy, MonoImageOpenStatus *status, gboolean refonly, gboolean metadata_only, const char *name, const char *filename) +mono_image_open_from_data_internal (MonoAssemblyLoadContext *alc, char *data, guint32 data_len, gboolean need_copy, MonoImageOpenStatus *status, gboolean metadata_only, const char *name, const char *filename) { MonoCLIImageInfo *iinfo; MonoImage *image; @@ -1707,7 +1707,7 @@ mono_image_open_from_data_internal (MonoAssemblyLoadContext *alc, char *data, gu image->filename = filename ? g_strdup (filename) : NULL; iinfo = g_new0 (MonoCLIImageInfo, 1); image->image_info = iinfo; - image->ref_only = refonly; + image->ref_only = FALSE; image->metadata_only = metadata_only; image->ref_count = 1; image->alc = alc; @@ -1726,7 +1726,7 @@ mono_image_open_from_data_alc (MonoAssemblyLoadContextGCHandle alc_gchandle, cha MONO_ENTER_GC_UNSAFE; MonoAssemblyLoadContext *alc = mono_alc_from_gchandle (alc_gchandle); - result = mono_image_open_from_data_internal (alc, data, data_len, need_copy, status, FALSE, FALSE, name, name); + result = mono_image_open_from_data_internal (alc, data, data_len, need_copy, status, FALSE, name, name); MONO_EXIT_GC_UNSAFE; return result; } @@ -1737,10 +1737,16 @@ mono_image_open_from_data_alc (MonoAssemblyLoadContextGCHandle alc_gchandle, cha MonoImage * mono_image_open_from_data_with_name (char *data, guint32 data_len, gboolean need_copy, MonoImageOpenStatus *status, gboolean refonly, const char *name) { + if (refonly) { + if (status) { + *status = MONO_IMAGE_IMAGE_INVALID; + return NULL; + } + } MonoImage *result; MONO_ENTER_GC_UNSAFE; MonoDomain *domain = mono_domain_get (); - result = mono_image_open_from_data_internal (mono_domain_default_alc (domain), data, data_len, need_copy, status, refonly, FALSE, name, name); + result = mono_image_open_from_data_internal (mono_domain_default_alc (domain), data, data_len, need_copy, status, FALSE, name, name); MONO_EXIT_GC_UNSAFE; return result; } @@ -1751,10 +1757,16 @@ mono_image_open_from_data_with_name (char *data, guint32 data_len, gboolean need MonoImage * mono_image_open_from_data_full (char *data, guint32 data_len, gboolean need_copy, MonoImageOpenStatus *status, gboolean refonly) { + if (refonly) { + if (status) { + *status = MONO_IMAGE_IMAGE_INVALID; + return NULL; + } + } MonoImage *result; MONO_ENTER_GC_UNSAFE; MonoDomain *domain = mono_domain_get (); - result = mono_image_open_from_data_internal (mono_domain_default_alc (domain), data, data_len, need_copy, status, refonly, FALSE, NULL, NULL); + result = mono_image_open_from_data_internal (mono_domain_default_alc (domain), data, data_len, need_copy, status, FALSE, NULL, NULL); MONO_EXIT_GC_UNSAFE; return result; } @@ -1768,7 +1780,7 @@ mono_image_open_from_data (char *data, guint32 data_len, gboolean need_copy, Mon MonoImage *result; MONO_ENTER_GC_UNSAFE; MonoDomain *domain = mono_domain_get (); - result = mono_image_open_from_data_internal (mono_domain_default_alc (domain), data, data_len, need_copy, status, FALSE, FALSE, NULL, NULL); + result = mono_image_open_from_data_internal (mono_domain_default_alc (domain), data, data_len, need_copy, status, FALSE, NULL, NULL); MONO_EXIT_GC_UNSAFE; return result; } diff --git a/src/mono/mono/metadata/metadata-internals.h b/src/mono/mono/metadata/metadata-internals.h index c17f4ee..ed39fd0 100644 --- a/src/mono/mono/metadata/metadata-internals.h +++ b/src/mono/mono/metadata/metadata-internals.h @@ -189,18 +189,16 @@ struct MonoTypeNameParse { typedef enum MonoAssemblyContextKind { /* Default assembly context: Load(String) and assembly references */ MONO_ASMCTX_DEFAULT = 0, - /* Reflection-only only context: ReflectionOnlyLoad and ReeflectionOnlyLoadFrom */ - MONO_ASMCTX_REFONLY = 1, /* LoadFrom context: LoadFrom() and references */ - MONO_ASMCTX_LOADFROM = 2, + MONO_ASMCTX_LOADFROM = 1, /* Individual assembly context (.NET Framework docs call this "not in * any context"): LoadFile(String) and Load(byte[]) are here. */ - MONO_ASMCTX_INDIVIDUAL = 3, + MONO_ASMCTX_INDIVIDUAL = 2, /* Used internally by the runtime, not visible to managed code */ - MONO_ASMCTX_INTERNAL = 4, + MONO_ASMCTX_INTERNAL = 3, - MONO_ASMCTX_LAST = 4 + MONO_ASMCTX_LAST = 3 } MonoAssemblyContextKind; typedef struct _MonoAssemblyContext { @@ -1176,7 +1174,7 @@ MonoImage *mono_image_open_raw (MonoAssemblyLoadContext *alc, const char *fname, MonoImage *mono_image_open_metadata_only (MonoAssemblyLoadContext *alc, const char *fname, MonoImageOpenStatus *status); -MonoImage *mono_image_open_from_data_internal (MonoAssemblyLoadContext *alc, char *data, guint32 data_len, gboolean need_copy, MonoImageOpenStatus *status, gboolean refonly, gboolean metadata_only, const char *name, const char *filename); +MonoImage *mono_image_open_from_data_internal (MonoAssemblyLoadContext *alc, char *data, guint32 data_len, gboolean need_copy, MonoImageOpenStatus *status, gboolean metadata_only, const char *name, const char *filename); MonoException *mono_get_exception_field_access_msg (const char *msg); diff --git a/src/mono/mono/metadata/metadata-update.c b/src/mono/mono/metadata/metadata-update.c index f1737a2..1da0e81 100644 --- a/src/mono/mono/metadata/metadata-update.c +++ b/src/mono/mono/metadata/metadata-update.c @@ -348,7 +348,7 @@ MonoImage* mono_image_open_dmeta_from_data (MonoImage *base_image, uint32_t generation, gconstpointer dmeta_bytes, uint32_t dmeta_length, MonoImageOpenStatus *status) { MonoAssemblyLoadContext *alc = mono_image_get_alc (base_image); - MonoImage *dmeta_image = mono_image_open_from_data_internal (alc, (char*)dmeta_bytes, dmeta_length, TRUE, status, FALSE, TRUE, NULL, NULL); + MonoImage *dmeta_image = mono_image_open_from_data_internal (alc, (char*)dmeta_bytes, dmeta_length, TRUE, status, TRUE, NULL, NULL); dmeta_image->generation = generation; diff --git a/src/mono/mono/mini/aot-runtime.c b/src/mono/mono/mini/aot-runtime.c index b8617b5..289bab8 100644 --- a/src/mono/mono/mini/aot-runtime.c +++ b/src/mono/mono/mini/aot-runtime.c @@ -2240,7 +2240,7 @@ load_aot_module (MonoAssemblyLoadContext *alc, MonoAssembly *assembly, gpointer */ return; - if (image_is_dynamic (assembly->image) || mono_asmctx_get_kind (&assembly->context) == MONO_ASMCTX_REFONLY || mono_domain_get () != mono_get_root_domain ()) + if (image_is_dynamic (assembly->image) || mono_domain_get () != mono_get_root_domain ()) return; mono_aot_lock (); diff --git a/src/mono/mono/tests/metadata-verifier/gen-md-tests.c b/src/mono/mono/tests/metadata-verifier/gen-md-tests.c index b59bc86..c5212fe 100644 --- a/src/mono/mono/tests/metadata-verifier/gen-md-tests.c +++ b/src/mono/mono/tests/metadata-verifier/gen-md-tests.c @@ -272,7 +272,7 @@ init_test_set (test_set_t *test_set) if (test_set->init) return; test_set->assembly_data = read_whole_file_and_close (test_set->assembly, &test_set->assembly_size); - test_set->image = mono_image_open_from_data_internal (mono_domain_default_alc (mono_root_domain_get ()), test_set->assembly_data, test_set->assembly_size, FALSE, &status, FALSE, FALSE, NULL, NULL); + test_set->image = mono_image_open_from_data_internal (mono_domain_default_alc (mono_root_domain_get ()), test_set->assembly_data, test_set->assembly_size, FALSE, &status, FALSE, NULL, NULL); if (!test_set->image || status != MONO_IMAGE_OK) { printf ("Could not parse image %s\n", test_set->assembly); exit (INVALID_BAD_FILE); -- 2.7.4