[NET6] Enable support for AssemblyLoadContext

grendello · grendello · commit 853fd1b5366d · 2021-06-29T17:09:05.000+02:00
Context: https://docs.microsoft.com/en-us/dotnet/api/system.runtime.loader.assemblyloadcontext?view=net-5.0 dotnet 6 removes support for AppDomains (technically, there still exists a single AppDomain, but creation of new ones is no longer possible), replacing them (in a way) with AssemblyLoadContext, which enables scoped loading of managed assemblies. Part of the change is the new set of MonoVM functions we need to call in order to load an assembly into either the default AssemblyLoadContext (early in the startup process) or into the application-created context later on during application run time. MonoVM also adds new preload hooks which work with the `ALC` instead of the older AppDomains. This commit adds support for `ALC` preload callbacks and the new assembly load functions.
diff --git a/src/monodroid/jni/embedded-assemblies.cc b/src/monodroid/jni/embedded-assemblies.cc
@@ -130,21 +130,45 @@ EmbeddedAssemblies::get_assembly_data (const MonoBundledAssembly *e, char*& asse
 	}
 }
 
+#if defined (NET6)
 MonoAssembly*
-#if defined (NET6) && defined (NET6_ALC_WORKS)
-EmbeddedAssemblies::open_from_bundles (MonoAssemblyName* aname, MonoAssemblyLoadContextGCHandle alc_gchandle, MonoError *error)
-#else // !(def NET6 && def NET6_ALC_WORKS)
-EmbeddedAssemblies::open_from_bundles (MonoAssemblyName* aname, bool ref_only)
-#endif // def NET6 && def NET6_ALC_WORKS
+EmbeddedAssemblies::open_from_bundles (MonoAssemblyName* aname, MonoAssemblyLoadContextGCHandle alc_gchandle, [[maybe_unused]] MonoError *error)
 {
-#if defined (NET6)
-	// NET6 doesn't support reference-only loads, define the variable here to minimize ifdefs in the code below
-#if defined (NET6_ALC_WORKS)
-	constexpr bool ref_only = false;
-#else // def NET6_ALC_WORKS
-	ref_only = false;
-#endif // ndef NET6_ALC_WORKS
+	auto loader = [&] (char *assembly_data, uint32_t assembly_data_size, const char *name) -> MonoImage* {
+		return mono_image_open_from_data_alc (
+			alc_gchandle,
+			assembly_data,
+			assembly_data_size,
+			0 /* need_copy */,
+			nullptr /* status */,
+			name
+		);
+	};
+
+	return open_from_bundles (aname, loader, false /* ref_only */);
+}
 #endif // def NET6
+
+MonoAssembly*
+EmbeddedAssemblies::open_from_bundles (MonoAssemblyName* aname, bool ref_only)
+{
+	auto loader = [&] (char *assembly_data, uint32_t assembly_data_size, const char *name) -> MonoImage* {
+		return mono_image_open_from_data_with_name (
+			assembly_data,
+			assembly_data_size,
+			0,
+			nullptr,
+			ref_only,
+			name
+		);
+	};
+
+	return open_from_bundles (aname, loader, ref_only);
+}
+
+MonoAssembly*
+EmbeddedAssemblies::open_from_bundles (MonoAssemblyName* aname, std::function<MonoImage*(char*, uint32_t, const char*)> loader, bool ref_only)
+{
 	const char *culture = mono_assembly_name_get_culture (aname);
 	const char *asmname = mono_assembly_name_get_name (aname);
 
@@ -185,19 +209,7 @@ EmbeddedAssemblies::open_from_bundles (MonoAssemblyName* aname, bool ref_only)
 		}
 
 		get_assembly_data (e, assembly_data, assembly_data_size);
-
-#if defined (NET6) && defined (NET6_ALC_WORKS)
-		image = mono_image_open_from_data_alc (
-			alc_gchandle,
-			assembly_data,
-			assembly_data_size,
-			0 /* need_copy */,
-			nullptr /* status */,
-			name.get ()
-		);
-#else // (def NET6 && def NET6_ALC_WORKS)
-		image = mono_image_open_from_data_with_name (assembly_data, assembly_data_size, 0, nullptr, ref_only, name.get ());
-#endif // !(def NET6 && def NET6_ALC_WORKS)
+		image = loader (assembly_data, assembly_data_size, name.get ());
 		if (image == nullptr) {
 			continue;
 		}
@@ -215,50 +227,48 @@ EmbeddedAssemblies::open_from_bundles (MonoAssemblyName* aname, bool ref_only)
 		log_info_nocheck (LOG_ASSEMBLY, "open_from_bundles: loaded assembly: %p\n", a);
 	}
 
-#if defined (NET6) && defined (NET6_ALC_WORKS)
-	if (error != nullptr) {
-		error->error_code = a == nullptr ? MONO_ERROR_NONE : MONO_ERROR_FILE_NOT_FOUND;
-	}
-#endif // def NET6 && def NET6_ALC_WORKS
 	return a;
 }
 
-#if defined (NET6) && defined (NET6_ALC_WORKS)
+#if defined (NET6)
 MonoAssembly*
 EmbeddedAssemblies::open_from_bundles (MonoAssemblyLoadContextGCHandle alc_gchandle, MonoAssemblyName *aname, [[maybe_unused]] char **assemblies_path, [[maybe_unused]] void *user_data, MonoError *error)
 {
-	log_warn (LOG_DEFAULT, __PRETTY_FUNCTION__);
 	return embeddedAssemblies.open_from_bundles (aname, alc_gchandle, error);
 }
-#else // def NET6 && def NET6_ALC_WORKS
+#else // def NET6
 MonoAssembly*
-EmbeddedAssemblies::open_from_bundles_full (MonoAssemblyName *aname, [[maybe_unused]] char **assemblies_path, [[maybe_unused]] void *user_data)
+EmbeddedAssemblies::open_from_bundles_refonly (MonoAssemblyName *aname, [[maybe_unused]] char **assemblies_path, [[maybe_unused]] void *user_data)
 {
-	return embeddedAssemblies.open_from_bundles (aname, false);
+	return embeddedAssemblies.open_from_bundles (aname, true);
 }
+#endif // ndef NET6
 
 MonoAssembly*
-EmbeddedAssemblies::open_from_bundles_refonly (MonoAssemblyName *aname, [[maybe_unused]] char **assemblies_path, [[maybe_unused]] void *user_data)
+EmbeddedAssemblies::open_from_bundles_full (MonoAssemblyName *aname, [[maybe_unused]] char **assemblies_path, [[maybe_unused]] void *user_data)
 {
-	return embeddedAssemblies.open_from_bundles (aname, true);
+	return embeddedAssemblies.open_from_bundles (aname, false);
 }
-#endif // !(def NET6 && def NET6_ALC_WORKS)
 
 void
-EmbeddedAssemblies::install_preload_hooks ()
+EmbeddedAssemblies::install_preload_hooks (bool early)
 {
-#if defined (NET6) && defined (NET6_ALC_WORKS)
-	mono_install_assembly_preload_hook_v3 (
-		open_from_bundles,
-		nullptr /* user_data */,
-		0 /* append */
-	);
-#else // def NET6 && def NET6_ALC_WORKS
-	mono_install_assembly_preload_hook (open_from_bundles_full, nullptr);
-#if !defined (NET6) // Reference-only loads don't exist in NET6
-	mono_install_assembly_refonly_preload_hook (open_from_bundles_refonly, nullptr);
-#endif // !def NET6
-#endif // !(def NET6 && def NET6_ALC_WORKS)
+	if (early) {
+		mono_install_assembly_preload_hook (open_from_bundles_full, nullptr);
+#if !defined (NET6)
+		mono_install_assembly_refonly_preload_hook (open_from_bundles_refonly, nullptr);
+#endif // ndef NET6
+	}
+
+#if defined (NET6)
+	if (!early) {
+		mono_install_assembly_preload_hook_v3 (
+			open_from_bundles,
+			nullptr /* user_data */,
+			0 /* append */
+		);
+	}
+#endif // ndef NET6
 }
 
 template<typename Key, typename Entry, int (*compare)(const Key*, const Entry*), bool use_extra_size>
diff --git a/src/monodroid/jni/embedded-assemblies.hh b/src/monodroid/jni/embedded-assemblies.hh
@@ -4,6 +4,7 @@
 
 #include <cstring>
 #include <limits>
+#include <functional>
 #include <mono/metadata/object.h>
 #include <mono/metadata/assembly.h>
 
@@ -50,7 +51,7 @@ namespace xamarin::android::internal {
 #endif
 		const char* typemap_managed_to_java (MonoReflectionType *type, const uint8_t *mvid);
 
-		void install_preload_hooks ();
+		void install_preload_hooks (bool early);
 		MonoReflectionType* typemap_java_to_managed (MonoString *java_type);
 
 		/* returns current number of *all* assemblies found from all invocations */
@@ -93,11 +94,12 @@ namespace xamarin::android::internal {
 		MonoReflectionType* typemap_java_to_managed (const char *java_type_name);
 		size_t register_from (const char *apk_file, monodroid_should_register should_register);
 		void gather_bundled_assemblies_from_apk (const char* apk, monodroid_should_register should_register);
-#if defined (NET6) && defined (NET6_ALC_WORKS)
+#if defined (NET6)
 		MonoAssembly* open_from_bundles (MonoAssemblyName* aname, MonoAssemblyLoadContextGCHandle alc_gchandle, MonoError *error);
-#else // def NET6 && def NET6_ALC_WORKS
+#endif // def NET6
 		MonoAssembly* open_from_bundles (MonoAssemblyName* aname, bool ref_only);
-#endif // !(def NET6 && def NET6_ALC_WORKS)
+		MonoAssembly* open_from_bundles (MonoAssemblyName* aname, std::function<MonoImage*(char*, uint32_t, const char*)> loader, bool ref_only);
+
 #if defined (DEBUG) || !defined (ANDROID)
 		template<typename H>
 		bool typemap_read_header (int dir_fd, const char *file_type, const char *dir_path, const char *file_path, uint32_t expected_magic, H &header, size_t &file_size, int &fd);
@@ -111,12 +113,12 @@ namespace xamarin::android::internal {
 		bool register_debug_symbols_for_assembly (const char *entry_name, MonoBundledAssembly *assembly, const mono_byte *debug_contents, int debug_size);
 
 		static md_mmap_info md_mmap_apk_file (int fd, uint32_t offset, uint32_t size, const char* filename, const char* apk);
-#if defined (NET6) && defined (NET6_ALC_WORKS)
-		static MonoAssembly* open_from_bundles (MonoAssemblyLoadContextGCHandle alc_gchandle, MonoAssemblyName *aname, char **assemblies_path, void *user_data, MonoError *error);
-#else // def NET6 && def NET6_ALC_WORKS
 		static MonoAssembly* open_from_bundles_full (MonoAssemblyName *aname, char **assemblies_path, void *user_data);
+#if defined (NET6)
+		static MonoAssembly* open_from_bundles (MonoAssemblyLoadContextGCHandle alc_gchandle, MonoAssemblyName *aname, char **assemblies_path, void *user_data, MonoError *error);
+#else // def NET6
 		static MonoAssembly* open_from_bundles_refonly (MonoAssemblyName *aname, char **assemblies_path, void *user_data);
-#endif // !(def NET6 && def NET6_ALC_WORKS)
+#endif // ndef NET6
 		static void get_assembly_data (const MonoBundledAssembly *e, char*& assembly_data, uint32_t& assembly_data_size);
 
 		void zip_load_entries (int fd, const char *apk_name, monodroid_should_register should_register);
diff --git a/src/monodroid/jni/monodroid-glue-internal.hh b/src/monodroid/jni/monodroid-glue-internal.hh
@@ -64,8 +64,11 @@ namespace xamarin::android::internal
 			true
 		>;
 
+		using load_assemblies_context_type = MonoAssemblyLoadContextGCHandle;
 		static constexpr pinvoke_library_map::size_type LIBRARY_MAP_INITIAL_BUCKET_COUNT = 1;
-#endif // def NET6
+#else // def NET6
+		using load_assemblies_context_type = MonoDomain*;
+#endif // ndef NET6
 
 #if defined (DEBUG) && !defined (WINDOWS)
 		struct RuntimeOptions {
@@ -222,7 +225,11 @@ namespace xamarin::android::internal
 		void disable_external_signal_handlers ();
 		void lookup_bridge_info (MonoDomain *domain, MonoImage *image, const OSBridge::MonoJavaGCBridgeType *type, OSBridge::MonoJavaGCBridgeInfo *info);
 		void load_assembly (MonoDomain *domain, jstring_wrapper &assembly);
-		void load_assemblies (MonoDomain *domain, bool preload, jstring_array_wrapper &assemblies);
+#if defined (NET6)
+		void load_assembly (MonoAssemblyLoadContextGCHandle alc_handle, jstring_wrapper &assembly);
+#endif // ndef NET6
+		void load_assemblies (load_assemblies_context_type ctx, bool preload, jstring_array_wrapper &assemblies);
+
 		void set_debug_options ();
 		void parse_gdb_options ();
 		void mono_runtime_init (dynamic_local_string<PROPERTY_VALUE_BUFFER_LEN>& runtime_args);
@@ -302,6 +309,8 @@ namespace xamarin::android::internal
 		int                 current_context_id = -1;
 
 #if defined (NET6)
+		MonoAssemblyLoadContextGCHandle default_alc = nullptr;
+
 		static std::mutex             pinvoke_map_write_lock;
 		static pinvoke_api_map        xa_pinvoke_map;
 		static pinvoke_library_map    other_pinvoke_map;
diff --git a/src/monodroid/jni/monodroid-glue.cc b/src/monodroid/jni/monodroid-glue.cc
@@ -837,7 +837,7 @@ MonodroidRuntime::mono_runtime_init ([[maybe_unused]] dynamic_local_string<PROPE
 	 * Looking for assemblies from the update dir takes precedence over
 	 * everything else, and thus must go LAST.
 	 */
-	embeddedAssemblies.install_preload_hooks ();
+	embeddedAssemblies.install_preload_hooks (true /* early */);
 #ifndef RELEASE
 	mono_install_assembly_preload_hook (open_from_update_dir, nullptr);
 #endif
@@ -894,8 +894,11 @@ MonodroidRuntime::create_domain (JNIEnv *env, jstring_array_wrapper &runtimeApks
 	}
 
 	MonoDomain *domain;
+#if !defined (NET6)
 	if (is_root_domain) {
+#endif // ndef NET6
 		domain = mono_jit_init_version (const_cast<char*> ("RootDomain"), const_cast<char*> ("mobile"));
+#if !defined (NET6)
 	} else {
 		MonoDomain* root_domain = mono_get_root_domain ();
 
@@ -909,6 +912,7 @@ MonodroidRuntime::create_domain (JNIEnv *env, jstring_array_wrapper &runtimeApks
 
 		domain = utils.monodroid_create_appdomain (root_domain, domain_name.get (), /*shadow_copy:*/ 1, /*shadow_directory:*/ androidSystem.get_override_dir (0));
 	}
+#endif // ndef NET6
 
 	if constexpr (is_running_on_desktop) {
 		if (is_root_domain) {
@@ -1615,50 +1619,75 @@ MonodroidRuntime::disable_external_signal_handlers (void)
 	}
 }
 
+#if defined (NET6)
 inline void
-MonodroidRuntime::load_assembly (MonoDomain *domain, jstring_wrapper &assembly)
+MonodroidRuntime::load_assembly (MonoAssemblyLoadContextGCHandle alc_handle, jstring_wrapper &assembly)
 {
+	log_warn (LOG_ASSEMBLY, __PRETTY_FUNCTION__);
+
 	timing_period total_time;
 	if (XA_UNLIKELY (utils.should_log (LOG_TIMING)))
 		total_time.mark_start ();
 
 	const char *assm_name = assembly.get_cstr ();
-	MonoAssemblyName *aname;
+	log_warn (LOG_ASSEMBLY, "  trying to load assembly: %s", assm_name);
+	MonoAssemblyName *aname = mono_assembly_name_new (assm_name);
+	log_warn (LOG_ASSEMBLY, "  aname == %p", aname);
+
+	MonoImageOpenStatus open_status;
+	mono_assembly_load_full_alc (alc_handle, aname, nullptr /* basedir */, &open_status);
+
+	mono_assembly_name_free (aname);
 
-	aname = mono_assembly_name_new (assm_name);
+	if (XA_UNLIKELY (utils.should_log (LOG_TIMING))) {
+		total_time.mark_end ();
+		TIMING_LOG_INFO (total_time, "Assembly load (ALC): %s", assm_name);
+	}
+}
+#endif // NET6
+
+inline void
+MonodroidRuntime::load_assembly (MonoDomain *domain, jstring_wrapper &assembly)
+{
+	timing_period total_time;
+	if (XA_UNLIKELY (utils.should_log (LOG_TIMING)))
+		total_time.mark_start ();
+
+	const char *assm_name = assembly.get_cstr ();
+	MonoAssemblyName *aname = mono_assembly_name_new (assm_name);
 
 #ifndef ANDROID
 	if (designerAssemblies.has_assemblies () && designerAssemblies.try_load_assembly (domain, aname) != nullptr) {
 		log_debug (LOG_ASSEMBLY, "Dynamically opened assembly %s", mono_assembly_name_get_name (aname));
 	} else
 #endif
-	if (domain != mono_domain_get ()) {
-		MonoDomain *current = mono_domain_get ();
-		mono_domain_set (domain, FALSE);
-		mono_assembly_load_full (aname, NULL, NULL, 0);
-		mono_domain_set (current, FALSE);
-	} else {
-		mono_assembly_load_full (aname, NULL, NULL, 0);
-	}
+		if (domain != mono_domain_get ()) {
+			MonoDomain *current = mono_domain_get ();
+			mono_domain_set (domain, FALSE);
+			mono_assembly_load_full (aname, NULL, NULL, 0);
+			mono_domain_set (current, FALSE);
+		} else {
+			mono_assembly_load_full (aname, NULL, NULL, 0);
+		}
 
 	mono_assembly_name_free (aname);
 
 	if (XA_UNLIKELY (utils.should_log (LOG_TIMING))) {
 		total_time.mark_end ();
-		TIMING_LOG_INFO (total_time, "Assembly load: %s preloaded", assm_name);
+		TIMING_LOG_INFO (total_time, "Assembly load (domain): %s", assm_name);
 	}
 }
 
 inline void
-MonodroidRuntime::load_assemblies (MonoDomain *domain, bool preload, jstring_array_wrapper &assemblies)
+MonodroidRuntime::load_assemblies (load_assemblies_context_type ctx, bool preload, jstring_array_wrapper &assemblies)
 {
 	timing_period total_time;
 	if (XA_UNLIKELY (utils.should_log (LOG_TIMING)))
 		total_time.mark_start ();
 
 	for (size_t i = 0; i < assemblies.get_length (); ++i) {
 		jstring_wrapper &assembly = assemblies [i];
-		load_assembly (domain, assembly);
+		load_assembly (ctx, assembly);
 		// only load the first "main" assembly if we are not preloading.
 		if (!preload)
 			break;
@@ -1692,12 +1721,25 @@ MonodroidRuntime::create_and_initialize_domain (JNIEnv* env, jclass runtimeClass
 		}
 	}
 
+#if defined (NET6)
+	default_alc = mono_alc_get_default_gchandle ();
+	abort_unless (default_alc != nullptr, "Default AssemblyLoadContext not found");
+
+	embeddedAssemblies.install_preload_hooks (false /* early */);
+	log_debug (LOG_ASSEMBLY, "ALC hooks installed");
+#endif // def NET6
+
 #ifndef ANDROID
 	if (assembliesBytes != nullptr)
 		designerAssemblies.add_or_update_from_java (domain, env, assemblies, assembliesBytes, assembliesPaths);
 #endif
 	bool preload = (androidSystem.is_assembly_preload_enabled () || (is_running_on_desktop && force_preload_assemblies));
-	load_assemblies (domain, preload, assemblies);
+
+#if defined (NET6)
+		load_assemblies (default_alc, preload, assemblies);
+#else // def NET6
+		load_assemblies (domain, preload, assemblies);
+#endif // ndef NET6
 	init_android_runtime (domain, env, runtimeClass, loader);
 
 	osBridge.add_monodroid_domain (domain);
diff --git a/src/monodroid/jni/util.cc b/src/monodroid/jni/util.cc
diff --git a/src/monodroid/jni/util.hh b/src/monodroid/jni/util.hh
