virtualmachine: detect armhf multiarch support

Author: illwieckz

src/engine/framework/VirtualMachine.cpp

@@ -354,6 +354,89 @@ static std::pair<Sys::OSHandle, IPC::Socket> InternalLoadModule(std::pair<IPC::S
 }
 
 #if defined(DAEMON_NACL_RUNTIME_ENABLED)
+
+#if defined(__linux__) || defined(DAEMON_LINUXULATOR)
+#if defined(YOKAI_ARCH_ARM64)
+enum class ArmhfSupport
+{
+	Supported,
+	Unsupported,
+	Unknown,
+};
+
+static void SilenceOutput()
+{
+	int devnull = open("/dev/null", O_WRONLY);
+
+	if (devnull < 0) {
+		_exit(200);
+	}
+
+	dup2(devnull, STDOUT_FILENO);
+	dup2(devnull, STDERR_FILENO);
+
+	close(devnull);
+}
+
+static ArmhfSupport CheckArmhfSupport(Str::StringRef probe)
+{
+	pid_t pid = fork();
+	if (pid < 0) {
+		return ArmhfSupport::Unknown;
+	}
+
+	if (pid == 0) {
+		SilenceOutput();
+
+		char *const argv[] = {
+			const_cast<char *>(probe.data()),
+			nullptr,
+		};
+
+		execve(probe.data(), argv, environ);
+
+		switch (errno)
+		{
+			case ENOEXEC:
+				// Kernel cannot execute the probe.
+				_exit(100);
+
+			case ENOENT:
+			case EACCES:
+				// Missing or inaccessible probe.
+				_exit(101);
+
+			default:
+				_exit(102);
+		}
+	}
+
+	int status;
+	if (waitpid(pid, &status, 0) < 0) {
+		return ArmhfSupport::Unknown;
+	}
+
+	if (!WIFEXITED(status)) {
+		return ArmhfSupport::Unknown;
+	}
+
+	switch (WEXITSTATUS(status))
+	{
+		case 100:
+			return ArmhfSupport::Unsupported;
+
+		case 101:
+		case 102:
+			return ArmhfSupport::Unknown;
+
+		default:
+			// The execve() call succeeded, so the probe has been executed properly.
+			return ArmhfSupport::Supported;
+	}
+}
+#endif // NACL_ARCH_ARM64
+#endif // defined(__linux__) || defined(DAEMON_LINUXULATOR)
+
 static std::pair<Sys::OSHandle, IPC::Socket> CreateNaClVM(std::pair<IPC::Socket, IPC::Socket> pair, Str::StringRef name, bool debug, bool extract, int debugLoader) {
 	CheckMinAddressSysctlTooLarge();
 	const std::string& libPath = FS::GetLibPath();
@@ -423,8 +506,27 @@ static std::pair<Sys::OSHandle, IPC::Socket> CreateNaClVM(std::pair<IPC::Socket,
 	// Only use armhf on arm64 when the hardware can do 32-bit.
 	bool useLdArmhf = hasLdArmhf && hasArmhf;
 
+#if defined(__linux__) || defined(DAEMON_LINUXULATOR)
 #if defined(YOKAI_ARCH_ARM64)
-	// TODO: Detect that the arm64 processor supports 32-bit hardware support.
+	std::string ldLoaderPath = FS::Path::Build(libPath, "libs-linux-armhf");
+	ldLoaderPath = FS::Path::Build(ldLoaderPath, "ld-linux-armhf.so.3");
+
+	switch (CheckArmhfSupport(ldLoaderPath))
+	{
+		case ArmhfSupport::Supported:
+			Log::Notice("Working armhf multiarch support.");
+			break;
+
+		case ArmhfSupport::Unsupported:
+			Log::Notice("Unsupported armhf multiarch.");
+			useLdArmhf = false;
+			break;
+
+		case ArmhfSupport::Unknown:
+			Log::Warn("Could not determine armhf multiarch support.");
+			useLdArmhf = false;
+			break;
+	}
 
 	if (useLdArmhf) {
 		if (!workaround_box64_preferArmhf.Get()) {
@@ -434,7 +536,8 @@ static std::pair<Sys::OSHandle, IPC::Socket> CreateNaClVM(std::pair<IPC::Socket,
 			Log::Notice("Preferring armhf multiarch over Box64 emulation.");
 		}
 	}
-#endif
+#endif // defined(YOKAI_ARCH_ARM64)
+#endif // defined(__linux__) || defined(DAEMON_LINUXULATOR)
 
 	// Only use rbox64 on arm64 when the hardware cannot do 32-bit.
 	bool useBox64 = hasBox64 && !useLdArmhf;