[native] Better p/invoke handling when loading foreign libraries (#10165)

Improve looking for "foreign" libraries when resolving a p/invoke symbol.

Foreign libraries are those which either aren't contained in the application APK
or which reside on the device in a system location. In such cases, we must attempt
to load the library using its name passed from the managed code (which uses the
`DllImport` attribute to name the library).

Since `DllImport` doesn't usually use full name of the target library (e.g. instead
of `liblog.so` it will use either `liblog` or `log`), we must modify the library
name so that the `dlopen(3)` call can find it on the filesystem. We must make sure
that the library name follows the `libNAME.so` convention before attempting to load
the library from filesystem..

This is an interim fix for us not finding e.g. the `liblog.so` library when the
`[DllImport("liblog")]` attribute is used in the managed code. The library resolution
and reloading system must be redesigned, which will happen in a separate PR as it is
currently not the highest priority task.

Author: grendello

src/native/clr/include/constants.hh

@@ -32,6 +32,7 @@ namespace xamarin::android {
 #endif
 		static constexpr std::string_view MANGLED_ASSEMBLY_NAME_EXT { ".so" };
 		static constexpr std::string_view dso_suffix { ".so" };
+		static constexpr std::string_view DSO_PREFIX { "lib" };
 
 	private:
 		static constexpr std::string_view RUNTIME_CONFIG_BLOB_BASE_NAME       { "libarc.bin" };

src/native/clr/include/host/pinvoke-override.hh

@@ -79,7 +79,7 @@ namespace xamarin::android {
 			if (lib_handle == nullptr) {
 				// We're being called as part of the p/invoke mechanism, we don't need to look in the AOT cache
 				constexpr bool PREFER_AOT_CACHE = false;
-				lib_handle = MonodroidDl::monodroid_dlopen (library_name, microsoft::java_interop::JAVA_INTEROP_LIB_LOAD_LOCALLY, PREFER_AOT_CACHE);
+				lib_handle = MonodroidDl::monodroid_dlopen<PREFER_AOT_CACHE> (library_name, microsoft::java_interop::JAVA_INTEROP_LIB_LOAD_LOCALLY);
 				if (lib_handle == nullptr) {
 					log_warn (LOG_ASSEMBLY, "Shared library '{}' not loaded, p/invoke '{}' may fail", optional_string (library_name), optional_string (symbol_name));
 					return nullptr;

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

@@ -92,19 +92,22 @@ namespace xamarin::android
 
 		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_from_any_directories (name, dl_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 (name, dl_flags, false /* skip_existing_check */);
+			handle = AndroidSystem::load_dso_from_any_directories (name, dl_flags);
 			return monodroid_dlopen_log_and_return (handle, name);
 		}
 
 	public:
-		[[gnu::flatten]]
-		static auto monodroid_dlopen (std::string_view const& name, int flags, bool prefer_aot_cache) noexcept -> void*
+		template<bool PREFER_AOT_CACHE> [[gnu::flatten]]
+		static auto monodroid_dlopen (std::string_view const& name, int flags) noexcept -> void*
 		{
 			if (name.empty ()) [[unlikely]] {
 				log_warn (LOG_ASSEMBLY, "monodroid_dlopen got a null name. This is not supported in NET+"sv);
@@ -115,7 +118,10 @@ namespace xamarin::android
 			log_debug (LOG_ASSEMBLY, "monodroid_dlopen: hash for name '{}' is {:x}", name, name_hash);
 
 			DSOCacheEntry *dso = nullptr;
-			if (prefer_aot_cache) {
+			if constexpr (PREFER_AOT_CACHE) {
+				// This code isn't currently used by CoreCLR, but it's possible that in the future we will have separate
+				// .so files for AOT-d assemblies, similar to MonoVM, so let's keep it.
+				//
 				// If we're asked to look in the AOT DSO cache, do it first.  This is because we're likely called from the
 				// MonoVM's dlopen fallback handler and it will not be a request to resolved a p/invoke, but most likely to
 				// find and load an AOT image for a managed assembly.  Since there might be naming/hash conflicts in this
@@ -183,7 +189,7 @@ namespace xamarin::android
 			// We're called by MonoVM via a callback, we might need to return an AOT DSO.
 			// See: https://github.com/dotnet/android/issues/9081
 			constexpr bool PREFER_AOT_CACHE = true;
-			return monodroid_dlopen (name, flags, PREFER_AOT_CACHE);
+			return monodroid_dlopen<PREFER_AOT_CACHE> (name, flags);
 		}
 
 		[[gnu::flatten]]

src/native/clr/include/runtime-base/util.hh

@@ -267,6 +267,12 @@ namespace xamarin::android {
 			return path[0] == '/';
 		}
 
+		[[gnu::flatten, gnu::always_inline]]
+		static auto path_has_directory_components (std::string_view const& path) noexcept -> bool
+		{
+			return !path.empty () && path.contains ('/');
+		}
+
 	private:
 		// TODO: needs some work to accept mixed params of different accepted types
 		template<size_t MaxStackSpace, detail::PathBuffer<MaxStackSpace> TBuffer, detail::PathComponentString ...TPart>

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

@@ -416,14 +416,27 @@ auto AndroidSystem::get_full_dso_path (std::string const& base_dir, std::string_
 		return false;
 	}
 
+	dynamic_local_path_string lib_path { dso_path };
+	bool have_so_extension = lib_path.ends_with (Constants::dso_suffix);
 	if (base_dir.empty () || Util::is_path_rooted (dso_path)) {
+		// Absolute path or no base path, can't do much with it
 		path.assign (dso_path);
-		return true; // Absolute path or no base path, can't do much with it
+		if (!have_so_extension) {
+			path.append (Constants::dso_suffix);
+		}
+
+		return true;
 	}
 
-	path.assign (base_dir)
-		.append ("/"sv)
-		.append (dso_path);
+	path.assign (base_dir).append (Constants::DIR_SEP);
+
+	if (!Util::path_has_directory_components (dso_path) && !lib_path.starts_with (Constants::DSO_PREFIX)) {
+		path.append (Constants::DSO_PREFIX);
+	}
+	path.append (dso_path);
+	if (!have_so_extension) {
+		path.append (Constants::dso_suffix);
+	}
 
 	return true;
 }
@@ -450,7 +463,7 @@ auto AndroidSystem::load_dso (std::string_view const& path, unsigned int dl_flag
 	return handle;
 }
 
-template<class TContainer> [[gnu::always_inline]] // TODO: replace with a concept
+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*
 {
 	if (dso_name.empty ()) {

src/native/common/include/runtime-base/strings.hh

@@ -743,6 +743,16 @@ namespace xamarin::android {
 			return starts_with (s.data (), s.length ());
 		}
 
+		[[gnu::always_inline]]
+		auto ends_with (std::string_view const& s) noexcept -> bool
+		{
+			if (empty () || s.length () > buffer.size ()) {
+				return false;
+			}
+
+			return memcmp (buffer.get () + (length () - s.length ()), s.data (), s.length ()) == 0;
+		}
+
 		[[gnu::always_inline]]
 		void set_length_after_direct_write (size_t new_length) noexcept
 		{