[CoreCLR] Add support to load assemblies from storage (#9917)

Context: ec0cbcf
Context: ea38c0c

Before Android 6.0 (API-23), native libraries within a `.apk` would
be compressed.  They would be extracted at installation time
"duplicating" the data.  (One set of `.so` files would be on-disk,
while the original set would remain within the `.apk`, compressed.)

API-23 introduced the [`//application/@android:extractNativeLibs`][0]
attribute, which allowed this behavior to change: when set to `false`,
native libraries within the `.apk` would be *stored uncompressed*,
and native libraries would *not* be extracted at install time.
This increased `.apk` size, but *decreased* post-install app sizes,
as there was no duplication of native library data.

The initial support for CoreCLR (ec0cbcf, ea38c0c, many others)
only supported `/application[@android:extractNativeLibs='false']`.
If this attribute was set to `true`, *or* you ran on a device older
than Android 6.0, then the app would abort during startup:

	A  Abort message: 'Filesystem mode not supported yet.'

Implement support for CoreCLR host to load assemblies from storage.

This adds the missing bits to load assembly store from device's filesystem
instead of from the APK when running application which has the
`android:extractNativeLibs` attribute set to `true` in its manifest.

[0]: https://developer.android.com/guide/topics/manifest/application-element#extractNativeLibs

Author: grendello

src/native/clr/host/CMakeLists.txt

@@ -33,6 +33,7 @@ set(XAMARIN_MONODROID_SOURCES
   host-jni.cc
   host-util.cc
   internal-pinvokes.cc
+  jni-remapping.cc
   os-bridge.cc
   pinvoke-override.cc
   typemap.cc

src/native/clr/host/generate-pinvoke-tables.cc

@@ -58,8 +58,8 @@ const std::vector<std::string> internal_pinvoke_names = {
 	"_monodroid_gref_log_new",
 	"monodroid_log",
 //	"monodroid_log_traces",
-//	"_monodroid_lookup_replacement_type",
-//	"_monodroid_lookup_replacement_method_info",
+	"_monodroid_lookup_replacement_type",
+	"_monodroid_lookup_replacement_method_info",
 //	"_monodroid_lref_log_delete",
 //	"_monodroid_lref_log_new",
 //	"_monodroid_max_gref_get",

src/native/clr/host/host.cc

@@ -1,4 +1,9 @@
+#include <sys/types.h>
+#include <dirent.h>
+
+#include <cerrno>
 #include <cstdio>
+#include <cstring>
 
 #include <coreclrhost.h>
 
@@ -62,10 +67,98 @@ auto Host::zip_scan_callback (std::string_view const& apk_path, int apk_fd, dyna
 	return false;
 }
 
+[[gnu::always_inline]]
+void Host::scan_filesystem_for_assemblies_and_libraries () noexcept
+{
+	std::string const& native_lib_dir = AndroidSystem::get_native_libraries_dir ();
+	log_debug (LOG_ASSEMBLY, "Looking for assemblies in '{}'", native_lib_dir);
+
+	DIR *lib_dir = opendir (native_lib_dir.c_str ());
+	if (lib_dir == nullptr) [[unlikely]] {
+		Helpers::abort_application (
+			LOG_ASSEMBLY,
+			std::format (
+				"Unable to open native library directory '{}'. {}",
+				native_lib_dir,
+				std::strerror (errno)
+			)
+		);
+	}
+
+	int dir_fd = dirfd (lib_dir);
+	if (dir_fd < 0) [[unlikely]] {
+		Helpers::abort_application (
+			LOG_ASSEMBLY,
+			std::format (
+				"Unable to obtain file descriptor for opened directory '{}'. {}",
+				native_lib_dir,
+				std::strerror (errno)
+			)
+		);
+	}
+
+	do {
+		errno = 0;
+		dirent *cur = readdir (lib_dir);
+		if (cur == nullptr) {
+			if (errno != 0) {
+				log_warn (LOG_ASSEMBLY, "Failed to open a directory entry from '{}': {}", native_lib_dir, std::strerror (errno));
+				continue; // No harm, keep going
+			}
+			break; // we're done
+		}
+
+		// We can ignore the obvious entries
+		if (cur->d_name[0] == '.') {
+			continue;
+		}
+
+		if (!found_assembly_store) {
+			found_assembly_store = Constants::assembly_store_file_name.compare (cur->d_name) == 0;
+			if (!found_assembly_store) {
+				continue;
+			}
+
+			log_debug (LOG_ASSEMBLY, "Found assembly store in '{}/{}'", native_lib_dir, Constants::assembly_store_file_name);
+			int store_fd = openat (dir_fd, cur->d_name, O_RDONLY);
+			if (store_fd < 0) {
+				Helpers::abort_application (
+					LOG_ASSEMBLY,
+					std::format (
+						"Unable to open assembly store '{}/{}' for reading. {}",
+						native_lib_dir,
+						Constants::assembly_store_file_name,
+						std::strerror (errno)
+					)
+				);
+			}
+
+			auto file_size = Util::get_file_size_at (dir_fd, cur->d_name);
+			if (!file_size) {
+				// get_file_size_at logged errno for us
+				Helpers::abort_application (
+					LOG_ASSEMBLY,
+					std::format (
+						"Unable to map assembly store '{}/{}'",
+						native_lib_dir,
+						Constants::assembly_store_file_name
+					)
+				);
+			}
+
+			AssemblyStore::map (store_fd, cur->d_name, 0, static_cast<uint32_t>(file_size.value ()));
+			close (store_fd);
+			break; // we've found all we need
+		}
+	} while (true);
+	closedir (lib_dir);
+}
+
 void Host::gather_assemblies_and_libraries (jstring_array_wrapper& runtimeApks, bool have_split_apks)
 {
 	if (!AndroidSystem::is_embedded_dso_mode_enabled ()) {
-		Helpers::abort_application ("Filesystem mode not supported yet.");
+		scan_filesystem_for_assemblies_and_libraries ();
+		return;
 	}
 
 	int64_t apk_count = static_cast<int64_t>(runtimeApks.get_length ());

src/native/clr/host/internal-pinvokes.cc

@@ -2,6 +2,7 @@
 #include <host/os-bridge.hh>
 #include <host/typemap.hh>
 #include <runtime-base/internal-pinvokes.hh>
+#include <runtime-base/jni-remapping.hh>
 
 using namespace xamarin::android;
 
@@ -75,3 +76,15 @@ void monodroid_free (void *ptr) noexcept
 {
 	free (ptr);
 }
+
+const char*
+_monodroid_lookup_replacement_type (const char *jniSimpleReference)
+{
+	return JniRemapping::lookup_replacement_type (jniSimpleReference);
+}
+
+const JniRemappingReplacementMethod*
+_monodroid_lookup_replacement_method_info (const char *jniSourceType, const char *jniMethodName, const char *jniMethodSignature)
+{
+	return JniRemapping::lookup_replacement_method_info (jniSourceType, jniMethodName, jniMethodSignature);
+}

src/native/clr/host/jni-remapping.cc

@@ -0,0 +1,97 @@
+#include <cstring>
+
+#include <runtime-base/logger.hh>
+#include <runtime-base/jni-remapping.hh>
+
+#include "xamarin-app.hh"
+
+using namespace xamarin::android;
+
+[[gnu::always_inline]]
+auto JniRemapping::equal (JniRemappingString const& left, const char *right, size_t right_len) noexcept -> bool
+{
+	if (left.length != static_cast<uint32_t>(right_len) || left.str[0] != *right) {
+		return false;
+	}
+
+	if (memcmp (left.str, right, right_len) == 0) {
+		return true;
+	}
+
+	return false;
+}
+
+auto JniRemapping::lookup_replacement_type (const char *jniSimpleReference) noexcept -> const char*
+{
+	if (application_config.jni_remapping_replacement_type_count == 0 || jniSimpleReference == nullptr || *jniSimpleReference == '\0') {
+		return nullptr;
+	}
+
+	size_t ref_len = strlen (jniSimpleReference);
+	for (size_t i = 0uz; i < application_config.jni_remapping_replacement_type_count; i++) {
+		JniRemappingTypeReplacementEntry const& entry = jni_remapping_type_replacements[i];
+
+		if (equal (entry.name, jniSimpleReference, ref_len)) {
+			return entry.replacement;
+		}
+	}
+
+	return nullptr;
+}
+
+auto JniRemapping::lookup_replacement_method_info (const char *jniSourceType, const char *jniMethodName, const char *jniMethodSignature) noexcept -> const JniRemappingReplacementMethod*
+{
+	if (application_config.jni_remapping_replacement_method_index_entry_count == 0 ||
+	    jniSourceType == nullptr || *jniSourceType == '\0' ||
+	    jniMethodName == nullptr || *jniMethodName == '\0') {
+		return nullptr;
+	}
+
+	size_t source_type_len = strlen (jniSourceType);
+
+	const JniRemappingIndexTypeEntry *type = nullptr;
+	for (size_t i = 0uz; i < application_config.jni_remapping_replacement_method_index_entry_count; i++) {
+		JniRemappingIndexTypeEntry const& entry = jni_remapping_method_replacement_index[i];
+
+		if (!equal (entry.name, jniSourceType, source_type_len)) {
+			continue;
+		}
+
+		type = &jni_remapping_method_replacement_index[i];
+		break;
+	}
+
+	if (type == nullptr || type->method_count == 0 || type->methods == nullptr) {
+		return nullptr;
+	}
+
+	size_t method_name_len = strlen (jniMethodName);
+	size_t signature_len = jniMethodSignature == nullptr ? 0uz : strlen (jniMethodSignature);
+
+	for (size_t i = 0uz; i < type->method_count; i++) {
+		JniRemappingIndexMethodEntry const& entry = type->methods[i];
+
+		if (!equal (entry.name, jniMethodName, method_name_len)) {
+			continue;
+		}
+
+		if (entry.signature.length == 0 || equal (entry.signature, jniMethodSignature, signature_len)) {
+			return &type->methods[i].replacement;
+		}
+
+		const char *sig_end = jniMethodSignature + signature_len;
+		if (*sig_end == ')') {
+			continue;
+		}
+
+		while (sig_end != jniMethodSignature && *sig_end != ')') {
+			sig_end--;
+		}
+
+		if (equal (entry.signature, jniMethodSignature, static_cast<size_t>(sig_end - jniMethodSignature) + 1uz)) {
+			return &type->methods[i].replacement;
+		}
+	}
+
+	return nullptr;
+}

src/native/clr/host/pinvoke-tables.include

@@ -11,7 +11,8 @@
 namespace {
 #if INTPTR_MAX == INT64_MAX
 	//64-bit internal p/invoke table
-	std::array<PinvokeEntry, 11> internal_pinvokes {{
+	std::array<PinvokeEntry, 13> internal_pinvokes {{
+		{0x423c8f539a2c56d2, "_monodroid_lookup_replacement_type", reinterpret_cast<void*>(&_monodroid_lookup_replacement_type)},
 		{0x4310c1531ddddc14, "__android_log_print", reinterpret_cast<void*>(&__android_log_print)},
 		{0x4b1956138764939a, "_monodroid_gref_log_new", reinterpret_cast<void*>(&_monodroid_gref_log_new)},
 		{0x9187e6bc6294cacf, "clr_typemap_managed_to_java", reinterpret_cast<void*>(&clr_typemap_managed_to_java)},
@@ -20,6 +21,7 @@ namespace {
 		{0xae3df96dda0143bd, "_monodroid_gref_log", reinterpret_cast<void*>(&_monodroid_gref_log)},
 		{0xb8306f71b963cd3d, "monodroid_log", reinterpret_cast<void*>(&monodroid_log)},
 		{0xb9bae9c43fb05089, "xamarin_app_init", reinterpret_cast<void*>(&xamarin_app_init)},
+		{0xc2a21d3f6c8ccc24, "_monodroid_lookup_replacement_method_info", reinterpret_cast<void*>(&_monodroid_lookup_replacement_method_info)},
 		{0xd1e121b94ea63f2e, "_monodroid_gref_get", reinterpret_cast<void*>(&_monodroid_gref_get)},
 		{0xd5151b00eb33d85e, "monodroid_TypeManager_get_java_class_name", reinterpret_cast<void*>(&monodroid_TypeManager_get_java_class_name)},
 		{0xf41c48df6f9be476, "monodroid_free", reinterpret_cast<void*>(&monodroid_free)},
@@ -516,14 +518,16 @@ constexpr hash_t system_security_cryptography_native_android_library_hash = 0x18
 constexpr hash_t system_globalization_native_library_hash = 0x28b5c8fca080abd5;
 #else
 	//32-bit internal p/invoke table
-	std::array<PinvokeEntry, 11> internal_pinvokes {{
+	std::array<PinvokeEntry, 13> internal_pinvokes {{
 		{0xb7a486a, "monodroid_TypeManager_get_java_class_name", reinterpret_cast<void*>(&monodroid_TypeManager_get_java_class_name)},
+		{0x333d4835, "_monodroid_lookup_replacement_method_info", reinterpret_cast<void*>(&_monodroid_lookup_replacement_method_info)},
 		{0x39e5b5d4, "__android_log_print", reinterpret_cast<void*>(&__android_log_print)},
 		{0x656e00bd, "clr_typemap_managed_to_java", reinterpret_cast<void*>(&clr_typemap_managed_to_java)},
 		{0xa04e5d1c, "monodroid_free", reinterpret_cast<void*>(&monodroid_free)},
 		{0xb02468aa, "_monodroid_gref_get", reinterpret_cast<void*>(&_monodroid_gref_get)},
 		{0xb6431f9a, "clr_typemap_java_to_managed", reinterpret_cast<void*>(&clr_typemap_java_to_managed)},
 		{0xbe8d7701, "_monodroid_gref_log_new", reinterpret_cast<void*>(&_monodroid_gref_log_new)},
+		{0xc439b5d7, "_monodroid_lookup_replacement_type", reinterpret_cast<void*>(&_monodroid_lookup_replacement_type)},
 		{0xc5146c54, "_monodroid_gref_log_delete", reinterpret_cast<void*>(&_monodroid_gref_log_delete)},
 		{0xe7e77ca5, "_monodroid_gref_log", reinterpret_cast<void*>(&_monodroid_gref_log)},
 		{0xeac7f6e3, "xamarin_app_init", reinterpret_cast<void*>(&xamarin_app_init)},
@@ -1021,6 +1025,6 @@ constexpr hash_t system_security_cryptography_native_android_library_hash = 0x93
 constexpr hash_t system_globalization_native_library_hash = 0xa66f1e5a;
 #endif
 
-constexpr size_t internal_pinvokes_count = 11;
+constexpr size_t internal_pinvokes_count = 13;
 constexpr size_t dotnet_pinvokes_count = 477;
 } // end of anonymous namespace

src/native/clr/include/constants.hh

@@ -31,6 +31,7 @@ namespace xamarin::android {
 		static constexpr bool is_debug_build = true;
 #endif
 		static constexpr std::string_view MANGLED_ASSEMBLY_NAME_EXT { ".so" };
+		static constexpr std::string_view dso_suffix { ".so" };
 
 	private:
 		static constexpr std::string_view RUNTIME_CONFIG_BLOB_BASE_NAME       { "libarc.bin" };
@@ -94,7 +95,15 @@ namespace xamarin::android {
 	private:
 		static constexpr size_t split_config_abi_apk_name_size = calc_size (split_config_prefix, android_abi, split_config_extension);
 
+		static constexpr std::string_view assembly_store_prefix { "libassemblies." };
+		static constexpr std::string_view assembly_store_extension { ".blob" };
+		static constexpr size_t assembly_store_file_name_size = calc_size (assembly_store_prefix, android_lib_abi, assembly_store_extension, dso_suffix);
+		static constexpr auto assembly_store_file_name_array = concat_string_views<assembly_store_file_name_size> (assembly_store_prefix, android_lib_abi, assembly_store_extension, dso_suffix);
+
 	public:
+		// .data() must be used otherwise string_view length will include the trailing \0 in the array
+		static constexpr std::string_view assembly_store_file_name { assembly_store_file_name_array.data () };
+
 		static constexpr auto split_config_abi_apk_name = concat_string_views<split_config_abi_apk_name_size> (split_config_prefix, android_abi, split_config_extension);
 
 		//

src/native/clr/include/host/host.hh

@@ -33,6 +33,7 @@ namespace xamarin::android {
 		static void create_xdg_directories_and_environment (jstring_wrapper &homeDir) noexcept;
 		static auto zip_scan_callback (std::string_view const& apk_path, int apk_fd, dynamic_local_string<SENSIBLE_PATH_MAX> const& entry_name, uint32_t offset, uint32_t size) -> bool;
 		static void gather_assemblies_and_libraries (jstring_array_wrapper& runtimeApks, bool have_split_apks);
+		static void scan_filesystem_for_assemblies_and_libraries () noexcept;
 
 		static size_t clr_get_runtime_property (const char *key, char *value_buffer, size_t value_buffer_size, void *contract_context) noexcept;
 		static bool clr_external_assembly_probe (const char *path, void **data_start, int64_t *size) noexcept;

src/native/clr/include/runtime-base/android-system.hh

@@ -70,6 +70,11 @@ namespace xamarin::android {
 			primary_override_dir = determine_primary_override_dir (home);
 		}
 
+		static auto get_native_libraries_dir () noexcept -> std::string const&
+		{
+			return native_libraries_dir;
+		}
+
 		static void create_update_dir (std::string const& override_dir) noexcept
 		{
 			if constexpr (Constants::is_release_build) {
@@ -141,6 +146,7 @@ namespace xamarin::android {
 		static inline bool running_in_emulator = false;
 		static inline bool embedded_dso_mode_enabled = false;
 		static inline std::string primary_override_dir;
+		static inline std::string native_libraries_dir;
 
 #if defined (DEBUG)
 		static inline std::unordered_map<std::string, std::string> bundled_properties;

src/native/clr/include/runtime-base/internal-pinvokes.hh

@@ -2,6 +2,7 @@
 
 #include <jni.h>
 
+#include <xamarin-app.hh>
 #include "logger.hh"
 
 int _monodroid_gref_get () noexcept;
@@ -13,3 +14,5 @@ bool clr_typemap_java_to_managed (const char *java_type_name, char const** assem
 void monodroid_log (xamarin::android::LogLevel level, LogCategories category, const char *message) noexcept;
 char* monodroid_TypeManager_get_java_class_name (jclass klass) noexcept;
 void monodroid_free (void *ptr) noexcept;
+const char* _monodroid_lookup_replacement_type (const char *jniSimpleReference);
+const JniRemappingReplacementMethod* _monodroid_lookup_replacement_method_info (const char *jniSourceType, const char *jniMethodName, const char *jniMethodSignature);