Native side WIP

Author: grendello

src/native/clr/host/host.cc

@@ -17,6 +17,7 @@
 #include <host/os-bridge.hh>
 #include <host/runtime-util.hh>
 #include <runtime-base/android-system.hh>
+#include <runtime-base/dso-loader.hh>
 #include <runtime-base/jni-wrappers.hh>
 #include <runtime-base/logger.hh>
 #include <runtime-base/search.hh>
@@ -421,6 +422,8 @@ void Host::Java_mono_android_Runtime_initInternal (
 		}
 	);
 
+	DsoLoader::init (env, RuntimeUtil::get_class_from_runtime_field (env, runtimeClass, "java_lang_System", true));
+
 	struct JnienvInitializeArgs init = {};
 	init.javaVm                                         = jvm;
 	init.env                                            = env;

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

@@ -104,16 +104,15 @@ namespace xamarin::android {
 		static void detect_embedded_dso_mode (jstring_array_wrapper& appDirs) noexcept;
 		static void setup_environment () noexcept;
 		static void setup_app_library_directories (jstring_array_wrapper& runtimeApks, jstring_array_wrapper& appDirs, bool have_split_apks) noexcept;
-		static auto load_dso (std::string_view const& path, unsigned int dl_flags, bool skip_exists_check) noexcept -> void*;
-		static auto load_dso_from_any_directories (std::string_view const& name, unsigned int dl_flags) noexcept -> void*;
+		static auto load_dso_from_any_directories (std::string_view const& name, int dl_flags, bool is_jni) noexcept -> void*;
 
 	private:
 		static auto get_full_dso_path (std::string const& base_dir, std::string_view const& dso_path, dynamic_local_string<SENSIBLE_PATH_MAX>& path) noexcept -> bool;
 
 		template<class TContainer> // TODO: replace with a concept
-		static auto load_dso_from_specified_dirs (TContainer directories, std::string_view const& dso_name, unsigned int dl_flags) noexcept -> void*;
-		static auto load_dso_from_app_lib_dirs (std::string_view const& name, unsigned int dl_flags) noexcept -> void*;
-		static auto load_dso_from_override_dirs (std::string_view const& name, unsigned int dl_flags) noexcept -> void*;
+		static auto load_dso_from_specified_dirs (TContainer directories, std::string_view const& dso_name, int dl_flags, bool is_jni) noexcept -> void*;
+		static auto load_dso_from_app_lib_dirs (std::string_view const& name, int dl_flags, bool is_jni) noexcept -> void*;
+		static auto load_dso_from_override_dirs (std::string_view const& name, int dl_flags, bool is_jni) noexcept -> void*;
 		static auto lookup_system_property (std::string_view const &name, size_t &value_len) noexcept -> const char*;
 		static auto monodroid__system_property_get (std::string_view const&, char *sp_value, size_t sp_value_len) noexcept -> int;
 		static auto get_max_gref_count_from_system () noexcept -> long;

src/native/clr/include/runtime-base/monodroid-dl.hh

@@ -12,6 +12,7 @@
 #include "../xamarin-app.hh"
 
 #include "android-system.hh"
+#include <runtime-base/dso-loader.hh>
 #include <runtime-base/search.hh>
 #include "startup-aware-lock.hh"
 
@@ -72,39 +73,6 @@ namespace xamarin::android
 			return find_dso_cache_entry_common<CacheKind::DSO> (hash);
 		}
 
-		static auto monodroid_dlopen_log_and_return (void *handle, std::string_view const& full_name) -> void*
-		{
-			if (handle == nullptr) {
-				const char *load_error = dlerror ();
-				if (load_error == nullptr) {
-					load_error = "Unknown error";
-				}
-				log_error (
-					LOG_ASSEMBLY,
-					"Could not load library '{}'. {}",
-					full_name,
-					load_error
-				);
-			}
-
-			return handle;
-		}
-
-		static auto monodroid_dlopen_ignore_component_or_load (std::string_view const& name, int flags) noexcept -> void*
-		{
-			// We first try to load the DSO using the passed name, it will cause `dlopen` to search our APK (or
-			// on-filesystem location), if necessary, so it's more efficient than trying to load from any specific
-			// directories first.
-			unsigned int dl_flags = static_cast<unsigned int>(flags);
-			void *handle = AndroidSystem::load_dso (name, dl_flags, false /* skip_existing_check */);
-			if (handle != nullptr) {
-				return monodroid_dlopen_log_and_return (handle, name);
-			}
-
-			handle = AndroidSystem::load_dso_from_any_directories (name, dl_flags);
-			return monodroid_dlopen_log_and_return (handle, name);
-		}
-
 	private:
 		[[gnu::always_inline]]
 		static auto get_dso_name (const DSOCacheEntry *const dso) -> std::string_view
@@ -149,10 +117,11 @@ namespace xamarin::android
 			log_debug (LOG_ASSEMBLY, "monodroid_dlopen: hash match {}found, DSO name is '{}'", dso == nullptr ? "not "sv : ""sv, get_dso_name (dso));
 
 			if (dso == nullptr) {
-				// DSO not known at build time, try to load it
-				return monodroid_dlopen_ignore_component_or_load (name, flags);
+				// DSO not known at build time, try to load it. Since we don't know whether or not the library extends
+				// JNI, we're going to assume it is and thus use System.loadLibrary eventually.
+				return DsoLoader::load (name, flags, true /* is_jni */);
 			} else if (dso->handle != nullptr) {
-				return monodroid_dlopen_log_and_return (dso->handle, get_dso_name (dso));
+				return dso->handle;
 			}
 
 			if (dso->ignore) {
@@ -179,21 +148,20 @@ namespace xamarin::android
 					dso->handle = android_dlopen_ext (dso_name.data (), flags, &dli);
 
 					if (dso->handle != nullptr) {
-						return monodroid_dlopen_log_and_return (dso->handle, dso_name);
+						return dso->handle;
 					}
 					break;
 				}
 			}
 #endif
-			unsigned int dl_flags = static_cast<unsigned int>(flags);
-			dso->handle = AndroidSystem::load_dso_from_any_directories (dso_name, dl_flags);
+			dso->handle = AndroidSystem::load_dso_from_any_directories (dso_name, flags, dso->is_jni_library);
 
 			if (dso->handle != nullptr) {
-				return monodroid_dlopen_log_and_return (dso->handle, dso_name);
+				return dso->handle;
 			}
 
-			dso->handle = AndroidSystem::load_dso_from_any_directories (name, dl_flags);
-			return monodroid_dlopen_log_and_return (dso->handle, name);
+			dso->handle = AndroidSystem::load_dso_from_any_directories (name, flags, dso->is_jni_library);
+			return dso->handle;
 		}
 
 		[[gnu::flatten]]

src/native/clr/runtime-base/android-system.cc

@@ -8,6 +8,7 @@
 #include <xamarin-app.hh>
 #include <runtime-base/android-system.hh>
 #include <runtime-base/cpu-arch.hh>
+#include <runtime-base/dso-loader.hh>
 #include <runtime-base/strings.hh>
 #include <runtime-base/util.hh>
 
@@ -435,30 +436,8 @@ auto AndroidSystem::get_full_dso_path (std::string const& base_dir, std::string_
 	return true;
 }
 
-auto AndroidSystem::load_dso (std::string_view const& path, unsigned int dl_flags, bool skip_exists_check) noexcept -> void*
-{
-	if (path.empty ()) [[unlikely]] {
-		return nullptr;
-	}
-
-	log_info (LOG_ASSEMBLY, "Trying to load shared library '{}'", path);
-	if (!skip_exists_check && !is_embedded_dso_mode_enabled () && !Util::file_exists (path)) {
-		log_info (LOG_ASSEMBLY, "Shared library '{}' not found", path);
-		return nullptr;
-	}
-
-	char *error = nullptr;
-	void *handle = java_interop_lib_load (path.data (), dl_flags, &error);
-	if (handle == nullptr && Util::should_log (LOG_ASSEMBLY)) {
-		log_info_nocheck_fmt (LOG_ASSEMBLY, "Failed to load shared library '{}'. {}", path, error);
-	}
-	java_interop_free (error);
-
-	return handle;
-}
-
 template<class TContainer> [[gnu::always_inline]]
-auto AndroidSystem::load_dso_from_specified_dirs (TContainer directories, std::string_view const& dso_name, unsigned int dl_flags) noexcept -> void*
+auto AndroidSystem::load_dso_from_specified_dirs (TContainer directories, std::string_view const& dso_name, int dl_flags, bool is_jni) noexcept -> void*
 {
 	if (dso_name.empty ()) {
 		return nullptr;
@@ -470,7 +449,7 @@ auto AndroidSystem::load_dso_from_specified_dirs (TContainer directories, std::s
 			continue;
 		}
 
-		void *handle = load_dso (full_path.get (), dl_flags, false);
+		void *handle = DsoLoader::load (full_path.get (), dl_flags, is_jni);
 		if (handle != nullptr) {
 			return handle;
 		}
@@ -479,26 +458,26 @@ auto AndroidSystem::load_dso_from_specified_dirs (TContainer directories, std::s
 	return nullptr;
 }
 
-auto AndroidSystem::load_dso_from_app_lib_dirs (std::string_view const& name, unsigned int dl_flags) noexcept -> void*
+auto AndroidSystem::load_dso_from_app_lib_dirs (std::string_view const& name, int dl_flags, bool is_jni) noexcept -> void*
 {
-	return load_dso_from_specified_dirs (app_lib_directories, name, dl_flags);
+	return load_dso_from_specified_dirs (app_lib_directories, name, dl_flags, is_jni);
 }
 
-auto AndroidSystem::load_dso_from_override_dirs (std::string_view const& name, unsigned int dl_flags) noexcept -> void*
+auto AndroidSystem::load_dso_from_override_dirs (std::string_view const& name, int dl_flags, bool is_jni) noexcept -> void*
 {
 	if constexpr (Constants::is_release_build) {
 		return nullptr;
 	} else {
-		return load_dso_from_specified_dirs (AndroidSystem::override_dirs, name, dl_flags);
+		return load_dso_from_specified_dirs (AndroidSystem::override_dirs, name, dl_flags, is_jni);
 	}
 }
 
 [[gnu::flatten]]
-auto AndroidSystem::load_dso_from_any_directories (std::string_view const& name, unsigned int dl_flags) noexcept -> void*
+auto AndroidSystem::load_dso_from_any_directories (std::string_view const& name, int dl_flags, bool is_jni) noexcept -> void*
 {
-	void *handle = load_dso_from_override_dirs (name, dl_flags);
+	void *handle = load_dso_from_override_dirs (name, dl_flags, is_jni);
 	if (handle == nullptr) {
-		handle = load_dso_from_app_lib_dirs (name, dl_flags);
+		handle = load_dso_from_app_lib_dirs (name, dl_flags, is_jni);
 	}
 	return handle;
 }

src/native/common/include/runtime-base/dso-loader.hh

@@ -0,0 +1,137 @@
+#pragma once
+
+#include <jni.h>
+#include <dlfcn.h>
+#include <android/dlext.h>
+
+#include <string_view>
+
+#include <runtime-base/android-system.hh>
+#include <runtime-base/util.hh>
+#include <shared/helpers.hh>
+
+namespace xamarin::android {
+	class DsoLoader
+	{
+	public:
+		[[gnu::flatten]]
+		static void init (JNIEnv *env, jclass systemClass)
+		{
+			jni_env = env;
+			systemKlass = systemClass;
+			System_loadLibrary = env->GetMethodID (systemClass, "loadLibrary", "(Ljava/lang/String;)V");
+			if (System_loadLibrary == nullptr) [[unlikely]] {
+				Helpers::abort_application ("Failed to look up the Java System.loadLibrary method.");
+			}
+		}
+
+		// Overload used to load libraries from the file system.
+		template<bool SkipExistsCheck = false>
+		[[gnu::always_inline, gnu::flatten]]
+		static auto load (std::string_view const& path, int flags, bool is_jni) -> void*
+		{
+			if (is_jni) {
+				return load_jni (path, true /* name_is_path */);
+			}
+
+			log_info (LOG_ASSEMBLY, "Trying to load shared library '{}'", path);
+			if constexpr (!SkipExistsCheck) {
+				if (!AndroidSystem::is_embedded_dso_mode_enabled () && !Util::file_exists (path)) {
+					log_info (LOG_ASSEMBLY, "Shared library '{}' not found", path);
+					return nullptr;
+				}
+			}
+
+			return log_and_return (dlopen (path.data (), flags), path);
+		}
+
+		// Overload used to load libraries from the APK.
+		[[gnu::always_inline, gnu::flatten]]
+		static auto load (int fd, off64_t offset, std::string_view const& name, int flags, bool is_jni) -> void*
+		{
+			if (is_jni) {
+				return load_jni (name, true /* name_is_path */);
+			}
+
+			android_dlextinfo dli;
+			dli.flags = ANDROID_DLEXT_USE_LIBRARY_FD | ANDROID_DLEXT_USE_LIBRARY_FD_OFFSET;
+			dli.library_fd = fd;
+			dli.library_fd_offset = offset;
+
+			return log_and_return (android_dlopen_ext (name.data (), flags, &dli), name);
+		}
+
+	private:
+		[[gnu::always_inline]]
+		static auto log_and_return (void *handle, std::string_view const& full_name) -> void*
+		{
+			if (handle != nullptr) [[likely]] {
+				return handle;
+			}
+
+			const char *load_error = dlerror ();
+			if (load_error == nullptr) {
+				load_error = "Unknown error";
+			}
+			log_error (
+				LOG_ASSEMBLY,
+				"Could not load library '{}'. {}"sv,
+				full_name,
+				load_error
+			);
+
+			return nullptr;
+		}
+
+		static auto load_jni (std::string_view const& name, bool name_is_path) -> void*
+		{
+			if (jni_env == nullptr || systemKlass == nullptr) [[unlikely]] {
+				Helpers::abort_application ("DSO loader class not initialized properly."sv);
+			}
+
+			// System.loadLibrary call is going to be slow anyway, so we can spend some more time generating an
+			// undecorated library name here instead of at build time. This saves us a little bit of space in
+			// `libxamarin-app.so` and makes the build code less complicated.
+			auto get_undecorated_name = [](std::string_view const& full_name, bool is_path) -> std::string_view {
+				std::string_view name;
+
+				if (!is_path) {
+					name = full_name;
+				} else {
+					name = full_name; // TODO: cut the path
+				}
+
+				size_t name_start = 0;
+				size_t name_end = full_name.length ();
+
+				if (name.starts_with ("lib"sv) && name.length () > 3) {
+					name_start = 3;
+				}
+
+				if (name.ends_with (".so"sv) && name.length () > 3) {
+					name_end -= 3;
+				}
+
+				if (name_start >= name_end) [[unlikely]] {
+					return name;
+				}
+
+				return std::move (name.substr (name_start, name.length () - name_end));
+			};
+
+			const std::string_view undecorated_lib_name = get_undecorated_name (name, name_is_path);
+
+			jstring lib_name = jni_env->NewStringUTF (undecorated_lib_name.data ());
+			jni_env->CallStaticVoidMethod (systemKlass, System_loadLibrary, lib_name);
+
+			// This is unfortunate, but since `System.loadLibrary` doesn't return the class handle, we must get it this
+			// way :(
+			return log_and_return (dlopen (name.data (), RTLD_NOLOAD), name);
+		}
+
+	private:
+		static inline jmethodID System_loadLibrary = nullptr;
+		static inline jclass systemKlass = nullptr;
+		static inline JNIEnv *jni_env = nullptr;
+	};
+}