[WIP] workaround for System.loadLibrary not working on some threads

Author: grendello

src/native/clr/host/CMakeLists.txt

@@ -154,6 +154,7 @@ macro(lib_target_options TARGET_NAME)
     xa::java-interop
     xa::pinvoke-override-precompiled
     xa::lz4
+    -landroid
     -llog
     -lcoreclr
   )

src/native/clr/host/dso-loader.cc

@@ -1,5 +1,4 @@
 #include <runtime-base/dso-loader.hh>
-
 #include <host/os-bridge.hh>
 
 using namespace xamarin::android;

src/native/clr/host/host.cc

@@ -4,6 +4,9 @@
 #include <cerrno>
 #include <cstdio>
 #include <cstring>
+#include <unistd.h>
+
+#include <android/looper.h>
 
 #include <coreclrhost.h>
 
@@ -422,7 +425,12 @@ void Host::Java_mono_android_Runtime_initInternal (
 		}
 	);
 
-	DsoLoader::init (env, RuntimeUtil::get_class_from_runtime_field (env, runtimeClass, "java_lang_System", true));
+	DsoLoader::init (
+		env,
+		RuntimeUtil::get_class_from_runtime_field (env, runtimeClass, "java_lang_System", true),
+		ALooper_forThread (), // main thread looper
+		gettid ()
+	);
 
 	struct JnienvInitializeArgs init = {};
 	init.javaVm                                         = jvm;

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

@@ -2,11 +2,16 @@
 
 #include <jni.h>
 #include <dlfcn.h>
+#include <unistd.h>
+
 #include <android/dlext.h>
+#include <android/looper.h>
 
 #include <string_view>
 
 #include <runtime-base/android-system.hh>
+#include <runtime-base/mainthread-dso-loader.hh>
+#include <runtime-base/system-loadlibrary-wrapper.hh>
 #include <runtime-base/util.hh>
 #include <shared/helpers.hh>
 
@@ -19,13 +24,11 @@ namespace xamarin::android {
 	{
 	public:
 		[[gnu::flatten]]
-		static void init (JNIEnv *env, jclass systemClass)
+		static void init (JNIEnv *env, jclass systemClass, ALooper *main_looper, pid_t _main_thread_id) noexcept
 		{
-			systemKlass = systemClass;
-			System_loadLibrary = env->GetStaticMethodID (systemClass, "loadLibrary", "(Ljava/lang/String;)V");
-			if (System_loadLibrary == nullptr) [[unlikely]] {
-				Helpers::abort_application ("Failed to look up the Java System.loadLibrary method.");
-			}
+			SystemLoadLibraryWrapper::init (env, systemClass);
+			MainThreadDsoLoader::init (main_looper);
+			main_thread_id = _main_thread_id;
 		}
 
 		// Overload used to load libraries from the file system.
@@ -68,6 +71,7 @@ namespace xamarin::android {
 
 	private:
 		static auto get_jnienv () noexcept -> JNIEnv*;
+		static auto load_jni_on_main_thread (std::string_view const& full_name, std::string const& undecorated_name) noexcept -> void*;
 
 		[[gnu::always_inline]]
 		static auto log_and_return (void *handle, std::string_view const& full_name) -> void*
@@ -145,25 +149,29 @@ namespace xamarin::android {
 				return name;
 			};
 
-			// std::string is needed because we must pass a NUL-terminated string to Java, otherwise
-			// strange things happen (and std::string_view is not necessarily such a string)
-			const std::string undecorated_lib_name { get_undecorated_name (name, name_is_path) };
-			log_debug (LOG_ASSEMBLY, "Undecorated library name: {}", undecorated_lib_name);
-
-			JNIEnv *jni_env = get_jnienv ();
-			jstring lib_name = jni_env->NewStringUTF (undecorated_lib_name.c_str ());
-			if (lib_name == nullptr) [[unlikely]] {
-				// It's an OOM, there's nothing better we can do
-				Helpers::abort_application ("Java string allocation failed while loading a shared library.");
-			}
-			jni_env->CallStaticVoidMethod (systemKlass, System_loadLibrary, lib_name);
-			if (jni_env->ExceptionCheck ()) {
-				log_debug (LOG_ASSEMBLY, "System.loadLibrary threw a Java exception. Will attempt to log it.");
-				jni_env->ExceptionDescribe ();
-				jni_env->ExceptionClear ();
-				log_debug (LOG_ASSEMBLY, "Java exception cleared");
-				// TODO: should we abort? Return `nullptr`? `dlopen` still has a chance to succeed, even if loadLibrary
-				//       failed but it won't call `JNI_OnLoad` etc, so the result might be less than perfect.
+			// So, we have a rather nasty problem here. If we're on a thread other than the main one (or, to be more
+			// precise - one not created by Java), we will NOT have the special class loader Android uses in JVM and
+			// which knows about the special application-specific .so paths (like the one inside the APK itself). For
+			// that reason, `System.loadLibrary` will not be able to find the requested .so and we can't pass it a full
+			// path to it, since it accepts only the undecorated library name.
+			// We have to call `System.loadLibrary` on the main thread, so that the special class loader is available to
+			// it. At the same time, we have to do it synchronously, because we must be able to get the library handle
+			// **here**. We could call to a Java function here, but then synchronization might be an issue. So, instead,
+			// we use a wrapper around System.loadLibrary that uses the ALooper native Android interface. It's a bit
+			// clunky (as it requires using a fake pipe(2) to force the looper to call us on the main thread) but it
+			// should work across all the Android versions.
+
+			// TODO: implement the above
+			if (gettid () == main_thread_id) {
+				if (!SystemLoadLibraryWrapper::load (get_jnienv (), get_undecorated_name (name, name_is_path))) {
+					// We could abort, but let's let the managed land react to this library missing. We cannot continue
+					// with `dlopen` below, because without `JNI_OnLoad` etc invoked, we might have nasty crashes in the
+					// library code if e.g. it assumes that `JNI_OnLoad` initialized all the Java class, method etc
+					// pointers.
+					return nullptr;
+				}
+			} else {
+				Helpers::abort_application ("Loading DSO on the main thread not implemented yet"sv);
 			}
 
 			// This is unfortunate, but since `System.loadLibrary` doesn't return the class handle, we must get it this
@@ -177,5 +185,6 @@ namespace xamarin::android {
 	private:
 		static inline jmethodID System_loadLibrary = nullptr;
 		static inline jclass systemKlass = nullptr;
+		static inline pid_t main_thread_id = 0;
 	};
 }

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

@@ -0,0 +1,98 @@
+#pragma once
+
+#include <cerrno>
+#include <cstring>
+#include <unistd.h>
+
+#include <format>
+#include <semaphore>
+#include <string_view>
+
+#include <android/looper.h>
+
+#include <shared/helpers.hh>
+
+namespace xamarin::android {
+	// This class is **strictly** one-shot-per-instance! That is, the `load` method mustn't be called on the
+	// same object more than once. This is by design, to make the code simpler.
+	class MainThreadDsoLoader
+	{
+	public:
+		explicit MainThreadDsoLoader () noexcept
+		{
+			if (pipe (pipe_fds) != 0) {
+				Helpers::abort_application (
+					LOG_ASSEMBLY,
+					std::format (
+						"Failed to create a pipe for main thread DSO loader. {}",
+						strerror (errno)
+					)
+				);
+			}
+
+			int ret = ALooper_addFd (
+				main_thread_looper,
+				pipe_fds[0],
+				ALOOPER_POLL_CALLBACK,
+				ALOOPER_EVENT_INPUT,
+				load_cb,
+				this
+			);
+
+			if (ret == -1) {
+				Helpers::abort_application ("Failed to init main looper with pipe file descriptors in the main thread DSO loader"sv);
+			}
+		}
+
+		MainThreadDsoLoader (const MainThreadDsoLoader&) = delete;
+		MainThreadDsoLoader (MainThreadDsoLoader&&) = delete;
+
+		virtual ~MainThreadDsoLoader () noexcept
+		{
+			if (pipe_fds[0] != -1) {
+				ALooper_removeFd (main_thread_looper, pipe_fds[0]);
+				close (pipe_fds[0]);
+			}
+
+			if (pipe_fds[1] != -1) {
+				close (pipe_fds[1]);
+			}
+
+			// No need to release the looper, it needs to stay acquired.
+		}
+
+		MainThreadDsoLoader& operator=(const MainThreadDsoLoader&) = delete;
+		MainThreadDsoLoader& operator=(MainThreadDsoLoader&&) = delete;
+
+		void load (std::string_view const& full_name, std::string const& undecorated_name) noexcept
+		{
+			// TODO: init load here by writing to pipe_fds[1]
+
+			// Wait for the callback to complete
+			load_complete_sem.acquire ();
+		}
+
+		static void init (ALooper *main_looper)
+		{
+			main_thread_looper = main_looper;
+
+			// This will keep the looper around for the lifetime of the application.
+			ALooper_acquire (main_looper);
+		}
+
+	private:
+		static auto load_cb (int fd, int events, void *data) noexcept -> int
+		{
+			auto self = reinterpret_cast<MainThreadDsoLoader*> (data);
+
+			self->load_complete_sem.release ();
+			return 0; // We're one-shot, 0 means just that
+		}
+
+	private:
+		int pipe_fds[2] = {-1, -1};
+		std::binary_semaphore load_complete_sem {0};
+
+		static inline ALooper *main_thread_looper = nullptr;
+	};
+}

src/native/common/include/runtime-base/system-loadlibrary-wrapper.hh

@@ -0,0 +1,54 @@
+#pragma once
+
+#include <string>
+#include <string_view>
+
+#include <jni.h>
+
+#include <shared/helpers.hh>
+#include <runtime-base/logger.hh>
+
+namespace xamarin::android {
+	class SystemLoadLibraryWrapper
+	{
+	public:
+		[[gnu::flatten]]
+		static void init (JNIEnv *env, jclass systemClass) noexcept
+		{
+			systemKlass = systemClass;
+			System_loadLibrary = env->GetStaticMethodID (systemClass, "loadLibrary", "(Ljava/lang/String;)V");
+			if (System_loadLibrary == nullptr) [[unlikely]] {
+				Helpers::abort_application ("Failed to look up the Java System.loadLibrary method.");
+			}
+		}
+
+		[[gnu::flatten]]
+		static auto load (JNIEnv *jni_env, std::string_view const& undecorated_lib_name) noexcept -> bool
+		{
+			// std::string is needed because we must pass a NUL-terminated string to Java, otherwise
+			// strange things happen (and std::string_view is not necessarily such a string)
+			const std::string lib_name { undecorated_lib_name };
+			log_debug (LOG_ASSEMBLY, "Undecorated library name: {}", lib_name);
+
+			jstring java_lib_name = jni_env->NewStringUTF (lib_name.c_str ());
+			if (java_lib_name == nullptr) [[unlikely]] {
+				// It's an OOM, there's nothing better we can do
+				Helpers::abort_application ("Java string allocation failed while loading a shared library.");
+			}
+			jni_env->CallStaticVoidMethod (systemKlass, System_loadLibrary, java_lib_name);
+			if (jni_env->ExceptionCheck ()) {
+				log_debug (LOG_ASSEMBLY, "System.loadLibrary threw a Java exception. Will attempt to log it.");
+				jni_env->ExceptionDescribe ();
+				jni_env->ExceptionClear ();
+				log_debug (LOG_ASSEMBLY, "Java exception cleared");
+				return false;
+			}
+
+			return true;
+		}
+
+	private:
+		static inline jmethodID System_loadLibrary = nullptr;
+		static inline jclass systemKlass = nullptr;
+	};
+}

src/native/common/runtime-base/CMakeLists.txt

@@ -2,6 +2,7 @@ set(LIB_NAME runtime-base-common)
 set(LIB_ALIAS xa::runtime-base-common)
 
 set(XA_RUNTIME_BASE_SOURCES
+  dso-loader.cc
   timing-internal.cc
 )
 add_clang_check_sources("${XA_RUNTIME_BASE_SOURCES}")

src/native/common/runtime-base/dso-loader.cc

@@ -0,0 +1,9 @@
+#include <runtime-base/dso-loader.hh>
+#include <runtime-base/mainthread-dso-loader.hh>
+
+using namespace xamarin::android;
+
+auto DsoLoader::load_jni_on_main_thread (std::string_view const& full_name, std::string const& undecorated_name) noexcept -> void*
+{
+	return nullptr;
+}

src/native/mono/monodroid/CMakeLists.txt

@@ -233,6 +233,7 @@ macro(lib_target_options TARGET_NAME)
     xa::pinvoke-override-precompiled
     xa::lz4
     -lmonosgen-2.0
+    -landroid
     -llog
   )
 endmacro ()

src/native/mono/monodroid/monodroid-glue.cc

@@ -1390,7 +1390,12 @@ MonodroidRuntime::Java_mono_android_Runtime_initInternal (JNIEnv *env, jclass kl
 	AndroidSystem::set_running_in_emulator (isEmulator);
 
 	java_System = RuntimeUtil::get_class_from_runtime_field (env, klass, "java_lang_System", true);
-	DsoLoader::init (env, java_System);
+	DsoLoader::init (
+		env,
+		RuntimeUtil::get_class_from_runtime_field (env, klass, "java_lang_System", true),
+		ALooper_forThread (), // main thread looper
+		gettid ()
+	);
 
 	java_TimeZone = RuntimeUtil::get_class_from_runtime_field (env, klass, "java_util_TimeZone", true);