[One .NET] Don't blindly load Mono components (dotnet#6507)

Whenever a .NET SDK for Android app starts, MonoVM will probe for a
number of Mono components:

	I monodroid-assembly: Trying to load shared library '/data/app/~~5lwn5C40pkRva2-L4kilZA==/com.microsoft.net6.helloandroid-MrYUTOqX7yZPkmtLOPnuuw==/split_config.arm64_v8a.apk!/lib/arm64-v8a/libmono-component-debugger.so'
	I monodroid-assembly: Failed to load shared library '/data/app/~~5lwn5C40pkRva2-L4kilZA==/com.microsoft.net6.helloandroid-MrYUTOqX7yZPkmtLOPnuuw==/split_config.arm64_v8a.apk!/lib/arm64-v8a/libmono-component-debugger.so'.
	                      dlopen failed: library "/data/app/~~5lwn5C40pkRva2-L4kilZA==/com.microsoft.net6.helloandroid-MrYUTOqX7yZPkmtLOPnuuw==/split_config.arm64_v8a.apk!/lib/arm64-v8a/libmono-component-debugger.so" not found

The above is repeated for, currently, 3 components.  Together, the
failed load attempts cost us around 1ms of startup time on Pixel 3 XL;
the time will depend on the speed of device's storage and CPU.

Since we know at the build time which components are included, we can
optimize the startup process by recording a flag indicating which
components can be loaded successfully.

Add a `mono_components_mask` field to `ApplicationConfig` which is set
to a bitmask indicating which components are packaged.  On application
startup, whenever `monodroid_dlopen` is called, we has the name of the
library passed to us by Mono and see if it matches one of the known
hashes for the various components.  If yes, we consult the mask stored
at build time and attempt to load the component only if its bit is set.

The above check is performed **only** during application startup since
that's when Mono probes for the components and it would be a waste of
time later in the application life.

Author: grendello

src/Xamarin.Android.Build.Tasks/Tasks/GeneratePackageManagerJava.cs

@@ -28,6 +28,8 @@ public class GeneratePackageManagerJava : AndroidTask
 		[Required]
 		public ITaskItem[] ResolvedUserAssemblies { get; set; }
 
+		public ITaskItem[] MonoComponents { get; set; }
+
 		public ITaskItem[] SatelliteAssemblies { get; set; }
 
 		public bool UseAssemblyStore { get; set; }
@@ -332,6 +334,19 @@ void AddEnvironment ()
 				assemblyNameWidth += abiNameLength + 2; // room for '/' and the terminating NUL
 			}
 
+			MonoComponent monoComponents = MonoComponent.None;
+			if (MonoComponents != null && MonoComponents.Length > 0) {
+				foreach (ITaskItem item in MonoComponents) {
+					if (String.Compare ("diagnostics_tracing", item.ItemSpec, StringComparison.OrdinalIgnoreCase) == 0) {
+						monoComponents |= MonoComponent.Tracing;
+					} else if (String.Compare ("hot_reload", item.ItemSpec, StringComparison.OrdinalIgnoreCase) == 0) {
+						monoComponents |= MonoComponent.HotReload;
+					} else if (String.Compare ("debugger", item.ItemSpec, StringComparison.OrdinalIgnoreCase) == 0) {
+						monoComponents |= MonoComponent.Debugger;
+					}
+				}
+			}
+
 			bool haveRuntimeConfigBlob = !String.IsNullOrEmpty (RuntimeConfigBinFilePath) && File.Exists (RuntimeConfigBinFilePath);
 			var appConfState = BuildEngine4.GetRegisteredTaskObjectAssemblyLocal<ApplicationConfigTaskState> (ApplicationConfigTaskState.RegisterTaskObjectKey, RegisteredTaskObjectLifetime.Build);
 
@@ -359,6 +374,7 @@ void AddEnvironment ()
 									  // and up to 4 other for arch-specific assemblies. Only **one** arch-specific store is ever loaded on the app
 									  // runtime, thus the number 2 here. All architecture specific stores contain assemblies with the same names
 									  // and in the same order.
+					MonoComponents = monoComponents,
 					HaveAssemblyStore = UseAssemblyStore,
 				};
 

src/Xamarin.Android.Build.Tasks/Tests/Xamarin.Android.Build.Tests/BuildTest.cs

@@ -23,6 +23,66 @@ namespace Xamarin.Android.Build.Tests
 	[Parallelizable (ParallelScope.Children)]
 	public partial class BuildTest : BaseTest
 	{
+		static object [] MonoComponentMaskChecks () => new object [] {
+			new object[] {
+				true,  // enableProfiler
+				true,  // useInterpreter
+				true,  // debugBuild
+				0x07U, // expectedMask
+			},
+
+			new object[] {
+				true,  // enableProfiler
+				false, // useInterpreter
+				true,  // debugBuild
+				0x05U, // expectedMask
+			},
+
+			new object[] {
+				false, // enableProfiler
+				false, // useInterpreter
+				true,  // debugBuild
+				0x01U, // expectedMask
+			},
+
+			new object[] {
+				true,  // enableProfiler
+				false, // useInterpreter
+				false, // debugBuild
+				0x04U, // expectedMask
+			},
+		};
+
+		[Test]
+		[TestCaseSource (nameof (MonoComponentMaskChecks))]
+		public void CheckMonoComponentsMask (bool enableProfiler, bool useInterpreter, bool debugBuild, uint expectedMask)
+		{
+			if (!Builder.UseDotNet) {
+				Assert.Ignore ("Valid only for NET6+ builds");
+				return;
+			}
+
+			var proj = new XamarinAndroidApplicationProject () {
+				IsRelease = !debugBuild,
+			};
+
+			proj.SetProperty (proj.ActiveConfigurationProperties, "AndroidEnableProfiler", enableProfiler.ToString ());
+			proj.SetProperty (proj.ActiveConfigurationProperties, "AndroidUseInterpreter", useInterpreter.ToString ());
+
+			var abis = new [] { "armeabi-v7a", "x86" };
+			proj.SetAndroidSupportedAbis (abis);
+
+			using (var b = CreateApkBuilder ()) {
+				Assert.IsTrue (b.Build (proj), "Build should have succeeded.");
+				string objPath = Path.Combine (Root, b.ProjectDirectory, proj.IntermediateOutputPath);
+
+				List<string> envFiles = EnvironmentHelper.GatherEnvironmentFiles (objPath, String.Join (";", abis), true);
+				EnvironmentHelper.ApplicationConfig app_config = EnvironmentHelper.ReadApplicationConfig (envFiles);
+				Assert.That (app_config, Is.Not.Null, "application_config must be present in the environment files");
+				Assert.IsTrue (app_config.mono_components_mask == expectedMask, "Expected Mono Components mask 0x{expectedMask:x}, got 0x{app_config.mono_components_mask:x}");
+			}
+		}
+
 		[Test]
 		[Category ("SmokeTests")]
 		public void SmokeTestBuildWithSpecialCharacters ([Values (false, true)] bool forms)

src/Xamarin.Android.Build.Tasks/Tests/Xamarin.Android.Build.Tests/Utilities/EnvironmentHelper.cs

@@ -34,9 +34,10 @@ public sealed class ApplicationConfig
 			public uint   number_of_assemblies_in_apk;
 			public uint   bundled_assembly_name_width;
 			public uint   number_of_assembly_blobs;
+			public uint   mono_components_mask;
 			public string android_package_name;
 		};
-		const uint ApplicationConfigFieldCount = 17;
+		const uint ApplicationConfigFieldCount = 18;
 
 		static readonly object ndkInitLock = new object ();
 		static readonly char[] readElfFieldSeparator = new [] { ' ', '\t' };
@@ -200,7 +201,12 @@ static ApplicationConfig ReadApplicationConfig (string envFile)
 						ret.number_of_assembly_blobs = ConvertFieldToUInt32 ("number_of_assembly_blobs", envFile, i, field [1]);
 						break;
 
-					case 16: // android_package_name: string / [pointer type]
+					case 16: // mono_components_mask: uint32_t / .word | .long
+						Assert.IsTrue (expectedUInt32Types.Contains (field [0]), $"Unexpected uint32_t field type in '{envFile}:{i}': {field [0]}");
+						ret.mono_components_mask = ConvertFieldToUInt32 ("mono_components_mask", envFile, i, field [1]);
+						break;
+
+					case 17: // android_package_name: string / [pointer type]
 						Assert.IsTrue (expectedPointerTypes.Contains (field [0]), $"Unexpected pointer field type in '{envFile}:{i}': {field [0]}");
 						pointers.Add (field [1].Trim ());
 						break;

src/Xamarin.Android.Build.Tasks/Utilities/ApplicationConfigNativeAssemblyGenerator.cs

@@ -6,6 +6,16 @@
 
 namespace Xamarin.Android.Tasks
 {
+	// Must match the MonoComponent enum in src/monodroid/jni/xamarin-app.hh
+	[Flags]
+	enum MonoComponent
+	{
+		None      = 0x00,
+		Debugger  = 0x01,
+		HotReload = 0x02,
+		Tracing   = 0x04,
+	}
+
 	class ApplicationConfigNativeAssemblyGenerator : NativeAssemblyGenerator
 	{
 		SortedDictionary <string, string> environmentVariables;
@@ -28,6 +38,7 @@ class ApplicationConfigNativeAssemblyGenerator : NativeAssemblyGenerator
 		public int NumberOfAssembliesInApk { get; set; }
 		public int NumberOfAssemblyStoresInApks { get; set; }
 		public int BundledAssemblyNameWidth { get; set; } // including the trailing NUL
+		public MonoComponent MonoComponents { get; set; }
 
 		public PackageNamingPolicy PackageNamingPolicy { get; set; }
 
@@ -103,6 +114,9 @@ protected override void WriteSymbols (StreamWriter output)
 				WriteCommentLine (output, "number_of_assembly_store_files");
 				size += WriteData (output, NumberOfAssemblyStoresInApks);
 
+				WriteCommentLine (output, "mono_components_mask");
+				size += WriteData (output, (uint)MonoComponents);
+
 				WriteCommentLine (output, "android_package_name");
 				size += WritePointer (output, MakeLocalLabel (stringLabel));
 

src/Xamarin.Android.Build.Tasks/Xamarin.Android.Common.targets

@@ -1566,6 +1566,7 @@ because xbuild doesn't support framework reference assemblies.
     _PrepareAssemblies;
     _PrepareEnvironmentAssemblySources;
     _GenerateEnvironmentFiles;
+    _IncludeNativeSystemLibraries;
   </_GeneratePackageManagerJavaDependsOn>
 </PropertyGroup>
 
@@ -1578,6 +1579,7 @@ because xbuild doesn't support framework reference assemblies.
     ResolvedAssemblies="@(_ResolvedAssemblies)"
     ResolvedUserAssemblies="@(_ResolvedUserAssemblies)"
     SatelliteAssemblies="@(_AndroidResolvedSatellitePaths)"
+    MonoComponents="@(_MonoComponent)"
     MainAssembly="$(TargetPath)"
     OutputDirectory="$(_AndroidIntermediateJavaSourceDirectory)mono"
     EnvironmentOutputDirectory="$(IntermediateOutputPath)android"

src/monodroid/jni/application_dso_stub.cc

@@ -55,6 +55,7 @@ ApplicationConfig application_config = {
 	.number_of_assemblies_in_apk = 2,
 	.bundled_assembly_name_width = 0,
 	.number_of_assembly_store_files = 2,
+	.mono_components_mask = MonoComponent::None,
 	.android_package_name = "com.xamarin.test",
 };
 

src/monodroid/jni/cpp-util.hh

@@ -5,6 +5,7 @@
 #include <cstdarg>
 #include <cstdlib>
 #include <memory>
+#include <type_traits>
 
 #include <semaphore.h>
 
@@ -123,5 +124,50 @@ namespace xamarin::android
 		return ret;
 	};
 
+	template <typename TEnum, std::enable_if_t<std::is_enum_v<TEnum>, int> = 0>
+	constexpr TEnum operator & (TEnum l, TEnum r) noexcept
+	{
+		using etype = std::underlying_type_t<TEnum>;
+		return static_cast<TEnum>(static_cast<etype>(l) & static_cast<etype>(r));
+	}
+
+	template <typename TEnum, std::enable_if_t<std::is_enum_v<TEnum>, int> = 0>
+	constexpr TEnum& operator &= (TEnum& l, TEnum r) noexcept
+	{
+		return l = (l & r);
+	}
+
+	template <typename TEnum, std::enable_if_t<std::is_enum_v<TEnum>, int> = 0>
+	constexpr TEnum operator | (TEnum l, TEnum r) noexcept
+	{
+		using etype = std::underlying_type_t<TEnum>;
+		return static_cast<TEnum>(static_cast<etype>(l) | static_cast<etype>(r));
+	}
+
+	template <typename TEnum, std::enable_if_t<std::is_enum_v<TEnum>, int> = 0>
+	constexpr TEnum& operator |= (TEnum& l, TEnum r) noexcept
+	{
+		return l = (l | r);
+	}
+
+	template <typename TEnum, std::enable_if_t<std::is_enum_v<TEnum>, int> = 0>
+	constexpr TEnum operator ~ (TEnum r) noexcept
+	{
+		using etype = std::underlying_type_t<TEnum>;
+		return static_cast<TEnum> (~static_cast<etype>(r));
+	}
+
+	template <typename TEnum, std::enable_if_t<std::is_enum_v<TEnum>, int> = 0>
+	constexpr TEnum operator ^ (TEnum l, TEnum r) noexcept
+	{
+		using etype = std::underlying_type_t<TEnum>;
+		return static_cast<TEnum>(static_cast<etype>(l) ^ static_cast<etype>(r));
+	}
+
+	template <typename TEnum, std::enable_if_t<std::is_enum_v<TEnum>, int> = 0>
+	constexpr TEnum& operator ^= (TEnum& l, TEnum r) noexcept
+	{
+		return l = (l ^ r);
+	}
 }
 #endif // !def __CPP_UTIL_HH

src/monodroid/jni/embedded-assemblies-zip.cc

@@ -297,6 +297,7 @@ EmbeddedAssemblies::zip_load_entries (int fd, const char *apk_name, [[maybe_unus
 		.prefix              = get_assemblies_prefix (),
 		.prefix_len          = get_assemblies_prefix_length (),
 		.buf_offset          = 0,
+		.compression_method  = 0,
 		.local_header_offset = 0,
 		.data_offset         = 0,
 		.file_size           = 0,

src/monodroid/jni/embedded-assemblies.cc

@@ -189,7 +189,7 @@ force_inline void
 EmbeddedAssemblies::map_runtime_file (XamarinAndroidBundledAssembly& file) noexcept
 {
 	md_mmap_info map_info = md_mmap_apk_file (file.apk_fd, file.data_offset, file.data_size, file.name);
-	if (monodroidRuntime.is_startup_in_progress ()) {
+	if (MonodroidRuntime::is_startup_in_progress ()) {
 		file.data = static_cast<uint8_t*>(map_info.area);
 	} else {
 		uint8_t *expected_null = nullptr;

src/monodroid/jni/generate-pinvoke-tables.cc

@@ -824,14 +824,14 @@ int main (int argc, char **argv)
 	print (output, "64-bit internal p/invoke table", "internal_pinvokes", internal_pinvokes64);
 	print (output, "64-bit DotNet p/invoke table", "dotnet_pinvokes", dotnet_pinvokes64);
 	output << std::endl;
-	write_library_name_hashes (xxhash64::hash, output);
+	write_library_name_hashes<uint64_t> (xxhash64::hash, output);
 
 	output << "#else" << std::endl;
 
 	print (output, "32-bit internal p/invoke table", "internal_pinvokes", internal_pinvokes32);
 	print (output, "32-bit DotNet p/invoke table", "dotnet_pinvokes", dotnet_pinvokes32);
 	output << std::endl;
-	write_library_name_hashes (xxhash32::hash, output);
+	write_library_name_hashes<uint32_t> (xxhash32::hash, output);
 
 	output << "#endif" << std::endl << std::endl;