diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml index 98e24d0b7..7f316d40d 100644 --- a/.github/workflows/build.yml +++ b/.github/workflows/build.yml @@ -173,7 +173,7 @@ jobs: uses: actions/cache@v4 with: path: app/src/main/assets/linuxfs - key: preloads-${{ env.PRELOAD_CACHE_VERSION }}-${{ hashFiles('app/src/main/cpp/fakeinput_steam.cpp', 'tools/linuxfs/preload/*.c', 'tools/linuxfs/build-x86-preloads.sh', 'tools/linuxfs/fex/*', 'tools/linuxfs/clipboard/*.c', 'tools/linuxfs/ssbs/*.c', 'tools/proot/fastpath/*.c', 'tools/linuxfs/overlay/usr/local/bin/*', 'tools/linuxfs/overlay/usr/bin/**', 'tools/linuxfs/desktop/*', 'tools/gamescope/release.env', 'tools/wlroots/release.env', 'tools/linuxfs/uruntime.env', 'tools/linuxfs/licenses/*', 'tools/mangoapp/*', 'tools/msitools/**', 'tools/linuxfs/debian-image.env') }} + key: preloads-${{ env.PRELOAD_CACHE_VERSION }}-${{ hashFiles('app/src/main/cpp/fakeinput_steam.cpp', 'tools/linuxfs/preload/*.c', 'tools/linuxfs/build-x86-preloads.sh', 'tools/linuxfs/fex/*', 'tools/linuxfs/clipboard/*.c', 'tools/linuxfs/ssbs/*.c', 'tools/proot/fastpath/*.c', 'tools/linuxfs/overlay/usr/local/bin/*', 'tools/linuxfs/overlay/usr/bin/**', 'tools/linuxfs/desktop/*', 'tools/gamescope/release.env', 'tools/wlroots/release.env', 'tools/linuxfs/uruntime.env', 'tools/linuxfs/licenses/*', 'tools/mangoapp/*', 'tools/msitools/**', 'tools/linuxfs/debian-image.env', 'tools/vkbridge/client/**', 'tools/vkbridge/common/**', 'tools/vkbridge/tests/**', 'tools/vkbridge/build-client-linux.sh') }} - name: Build libfakeinput.so and libblsession.so (glibc aarch64) if: steps.preloads.outputs.cache-hit != 'true' @@ -203,6 +203,8 @@ jobs: -o "$D/libssbs.so" tools/linuxfs/ssbs/ssbs_adapter.c -ldl aarch64-linux-gnu-strip --strip-unneeded "$D/libssbs.so" mkdir -p "$D/usr/local/bin" + # The Mali bridge's Linux side: ICD, manifest and self-test (tools/vkbridge). + tools/vkbridge/build-client-linux.sh "$D" aarch64-linux-gnu-gcc aarch64-linux-gnu-gcc -O2 -Wall -Wextra -o "$D/usr/local/bin/droiddeck-clipboard" tools/linuxfs/clipboard/clipboard.c -ldl aarch64-linux-gnu-strip --strip-unneeded "$D/usr/local/bin/droiddeck-clipboard" for script in tools/linuxfs/overlay/usr/local/bin/droiddeck-* tools/linuxfs/overlay/usr/local/bin/steam-compatibility; do @@ -393,6 +395,14 @@ jobs: run: | set -euo pipefail bash tools/linuxfs/check-preloads.sh app/src/main/assets/linuxfs + D=app/src/main/assets/linuxfs + syms() { readelf -Ws "$1" | awk '$4 == "FUNC" && $5 == "GLOBAL" {sub(/@.*/, "", $8); print $8}'; } + # The bridge ICD: libc only, and nothing exported but the loader's three entry points. + VKB="$D/usr/local/lib/vkbridge/libvulkan_droidbridge.so" + test -f "$VKB" && test -f "$D/usr/local/share/vkbridge/droidbridge_icd.json" && test -f "$D/usr/local/bin/droiddeck-vkbridge-smoke" + VKB_NEED=$(readelf -d "$VKB" | sed -n 's/.*NEEDED.*\[\(.*\)\]/\1/p' | grep -vx 'libc.so.6' | grep -vx 'ld-linux-aarch64.so.1' || true) + [ -z "$VKB_NEED" ] || { echo "::error::the bridge ICD needs $VKB_NEED"; exit 1; } + [ "$(syms "$VKB" | grep -c '^vk_icd')" = 3 ] || { echo "::error::the bridge ICD does not export the loader interface"; exit 1; } # The store download engines (app/src/main/rust/stores) are Rust, built by Gradle's # buildRustStores task through cargo-ndk. rustup and cargo are on the runner image; the Android diff --git a/app/build.gradle b/app/build.gradle index 26bb29762..7127c1b34 100644 --- a/app/build.gradle +++ b/app/build.gradle @@ -269,6 +269,24 @@ def buildRustStores = tasks.register('buildRustStores', Exec) { if (!skipRust) android.sourceSets.main.jniLibs.srcDir(rustJniLibsDir) tasks.named('preBuild').configure { dependsOn(buildRustStores) } +// The Mali bridge's server (tools/vkbridge, app/src/main/cpp/vkbridge) is a program, not a library: +// it runs beside the session as the app's child, so a driver crash ends that process and not the +// app. AGP's CMake integration packages only shared libraries, so the NDK's clang builds it here +// into one more jniLibs source, named libvkbridge_server.so so Android extracts it (the native +// library directory is the one place the app may exec from). +def vkbridgeJniLibsDir = layout.buildDirectory.dir('vkbridgeJniLibs') +def buildVkBridgeServer = tasks.register('buildVkBridgeServer', Exec) { + description = 'Builds the Vulkan bridge server (libvkbridge_server.so) with the NDK.' + inputs.dir(rootProject.file('tools/vkbridge/common')) + inputs.dir(layout.projectDirectory.dir('src/main/cpp/vkbridge')) + inputs.file(rootProject.file('tools/vkbridge/build-server-android.sh')) + outputs.dir(vkbridgeJniLibsDir) + commandLine 'bash', rootProject.file('tools/vkbridge/build-server-android.sh').absolutePath, + android.ndkDirectory.absolutePath, vkbridgeJniLibsDir.get().asFile.absolutePath +} +android.sourceSets.main.jniLibs.srcDir(vkbridgeJniLibsDir) +tasks.named('preBuild').configure { dependsOn(buildVkBridgeServer) } + dependencies { // The runtime tarball is a zstd-compressed tar. implementation 'com.github.luben:zstd-jni:1.5.2-3@aar' diff --git a/app/src/main/java/com/droiddeck/launcher/MainActivity.kt b/app/src/main/java/com/droiddeck/launcher/MainActivity.kt index 435f535a3..d4fcd0984 100644 --- a/app/src/main/java/com/droiddeck/launcher/MainActivity.kt +++ b/app/src/main/java/com/droiddeck/launcher/MainActivity.kt @@ -147,6 +147,8 @@ class MainActivity : ComponentActivity() { private var gameCores by mutableStateOf>(emptySet()) private var tuSysmem by mutableStateOf(false) private var zinkLazy by mutableStateOf(false) + private var vkBridge by mutableStateOf(false) + private val adrenoGpu by lazy { com.droiddeck.launcher.core.DeviceSupport.adreno() } private var noXalia by mutableStateOf(true) private var fastSync by mutableStateOf(false) private var syncFallback by mutableStateOf(true) @@ -556,6 +558,7 @@ class MainActivity : ComponentActivity() { FrontEndScreen( FrontEndState( installed = installed, ready = ready, available = available?.version, removalPending = removalPending, runtimeActionsBlocked = runtimeChangesBlocked(), + vkBridge = vkBridge, adreno = adrenoGpu, shortcutPicker = shortcutPicker, shortcutLibraryScanning = shortcutLibraryScanning, gameSyncFolder = gameSyncFolder, @@ -673,6 +676,7 @@ class MainActivity : ComponentActivity() { onInstallPackage = { id -> installPackage(id) }, onRemovePackage = { id -> removePackage(id) }, onRuntime = { onRuntimeButton() }, + onVkBridge = { on -> SessionPrefs.setVkBridge(this, on); vkBridge = on }, onFrameGenPick = { mode -> FrameGen.set(this, mode) frameGenLabel = FrameGen.label(this) @@ -1540,6 +1544,7 @@ class MainActivity : ComponentActivity() { gameCores = CpuCores.parse(SessionPrefs.gameCpus(this)).ifEmpty { CpuCores.all.toSet() } tuSysmem = SessionPrefs.tuSysmem(this) zinkLazy = SessionPrefs.zinkLazy(this) + vkBridge = SessionPrefs.vkBridge(this) noXalia = SessionPrefs.noXalia(this) fastSync = SessionPrefs.fastSync(this) syncFallback = SessionPrefs.syncFallback(this) @@ -1614,7 +1619,7 @@ class MainActivity : ComponentActivity() { // The runtime draws with Turnip, an Adreno driver: on Mali, Xclipse or PowerVR the // compositor gets no usable Vulkan device and a session is sound over a black screen. // Said before the download, not after it; the user may still go ahead. - if (installed == null && !com.droiddeck.launcher.core.DeviceSupport.adreno()) { showNonAdreno = release; return } + if (installed == null && !com.droiddeck.launcher.core.DeviceSupport.canDraw(this)) { showNonAdreno = release; return } install(release) } @@ -1626,7 +1631,7 @@ class MainActivity : ComponentActivity() { showPhantomGate = true return false } - val warn = installed == null && !com.droiddeck.launcher.core.DeviceSupport.adreno() + val warn = installed == null && !com.droiddeck.launcher.core.DeviceSupport.canDraw(this) if (warn && available != null) { showNonAdreno = available; return false } startActivity(intent) return true diff --git a/app/src/main/java/com/droiddeck/launcher/core/DeviceSupport.kt b/app/src/main/java/com/droiddeck/launcher/core/DeviceSupport.kt index 4170d69f1..26ff9229e 100644 --- a/app/src/main/java/com/droiddeck/launcher/core/DeviceSupport.kt +++ b/app/src/main/java/com/droiddeck/launcher/core/DeviceSupport.kt @@ -18,6 +18,16 @@ object DeviceSupport { fun adreno(): Boolean = File("/sys/class/kgsl/kgsl-3d0").exists() || File("/vendor/lib64/hw/vulkan.adreno.so").exists() + /** + * Whether the Linux side draws through the Vulkan bridge (tools/vkbridge): asked for in Setup + * and only on a GPU that is not an Adreno - an Adreno keeps Turnip whatever the setting says. + */ + fun vkBridge(context: Context): Boolean = + !adreno() && com.droiddeck.launcher.session.SessionPrefs.vkBridge(context) + + /** A session can draw: Adreno with Turnip, or anything else with the bridge turned on. */ + fun canDraw(context: Context): Boolean = adreno() || vkBridge(context) + /** The chip as the device names it, for the card that explains the refusal. */ fun gpuName(context: Context): String { val soc = if (Build.VERSION.SDK_INT >= 31) Build.SOC_MODEL.takeIf { it.isNotBlank() && it != Build.UNKNOWN } else null diff --git a/app/src/main/java/com/droiddeck/launcher/gpu/TurnipDriver.java b/app/src/main/java/com/droiddeck/launcher/gpu/TurnipDriver.java index 5cd414676..aa26f8e89 100644 --- a/app/src/main/java/com/droiddeck/launcher/gpu/TurnipDriver.java +++ b/app/src/main/java/com/droiddeck/launcher/gpu/TurnipDriver.java @@ -338,6 +338,13 @@ public final class TurnipDriver { if (forced.startsWith("a8")) return DRIVER_A8XX; if (forced.startsWith("a7")) return DRIVER_A7XX; } + // Not an Adreno (Mali, Xclipse...): Turnip cannot open a GPU without KGSL. The compositor + // runs on the phone's own driver, which has the dma-buf import it needs (the Mali bridge + // depends on it too). + if (!com.droiddeck.launcher.core.DeviceSupport.INSTANCE.adreno()) { + Log.i(TAG, "no KGSL: the compositor uses the system Vulkan driver"); + return null; + } String model = gpuModel(); Log.i(TAG, "gpu model: " + (model == null ? "unknown" : model)); if (model != null) { diff --git a/app/src/main/java/com/droiddeck/launcher/gpu/VkBridgeComponent.kt b/app/src/main/java/com/droiddeck/launcher/gpu/VkBridgeComponent.kt new file mode 100644 index 000000000..fe41309e3 --- /dev/null +++ b/app/src/main/java/com/droiddeck/launcher/gpu/VkBridgeComponent.kt @@ -0,0 +1,71 @@ +package com.droiddeck.launcher.gpu + +import android.os.Process +import android.util.Log +import com.droiddeck.launcher.core.HostProcess +import com.droiddeck.launcher.core.SessionPart +import java.io.File + +/** + * The Vulkan bridge server (tools/vkbridge, app/src/main/cpp/vkbridge) for one session. + * + * On a GPU without Adreno's KGSL nothing inside the Linux runtime can reach the GPU: Turnip needs + * KGSL, and the phone's own driver is a bionic library a glibc program cannot load. The server is + * a bionic process the app starts here - executed from the native library directory like the + * DirectAudio relay - which loads the system Vulkan loader and runs the Vulkan calls the + * session's programs send it through the bridge ICD over a Unix socket. It is the app's child, so + * it dies with the app (it also asks for that with PR_SET_PDEATHSIG). + * + * Started before the guest and waited for: the server runs a self-test first (which memory + * sharing works on this GPU), and only then listens; a program that starts before the socket + * exists would find no Vulkan driver. + */ +class VkBridgeComponent(private val socket: File, private val logFile: File) : SessionPart() { + @Volatile private var pid = -1 + @Volatile private var exited = false + + override fun start() { + stop() + val binary = File(app().applicationInfo.nativeLibraryDir, BINARY) + if (!binary.isFile) { + Log.e(TAG, "server missing at $binary; the session will have no Vulkan") + return + } + socket.parentFile?.mkdirs() + socket.delete() + exited = false + val cmd = listOf(binary.absolutePath, "--socket", socket.absolutePath, "--log", logFile.absolutePath) + .joinToString(" ") { it.replace("\\", "\\\\").replace(" ", "\\ ") } + val env = arrayOf("HOME=" + app().filesDir) + pid = HostProcess.start(cmd, env, app().filesDir, { status -> + exited = true + Log.w(TAG, "server exited with status $status") + runCatching { logFile.appendText("== vkbridge server exited with status $status\n") } + }, { line -> Log.i(TAG, line) }) + // The self-test takes about a second; a cold driver can take longer. + val deadline = System.currentTimeMillis() + 15_000L + while (!socket.exists() && !exited && System.currentTimeMillis() < deadline) { + try { Thread.sleep(50L) } catch (e: InterruptedException) { Thread.currentThread().interrupt(); break } + } + Log.i(TAG, if (socket.exists()) "server ready (pid $pid) at $socket" else "server NOT ready (pid $pid, exited=$exited); see $logFile") + } + + override fun stop() { + if (pid > 0) { + Process.killProcess(pid) + pid = -1 + } + socket.delete() + } + + override fun suspendPid(): Int = pid + + companion object { + private const val TAG = "VkBridge" + /** The server, named as a library so Android extracts it and lets the app run it. */ + const val BINARY = "libvkbridge_server.so" + /** Inside the runtime (staged by SessionFiles). */ + const val GUEST_ICD = "/usr/local/share/vkbridge/droidbridge_icd.json" + const val GUEST_LIB = "/usr/local/lib/vkbridge/libvulkan_droidbridge.so" + } +} diff --git a/app/src/main/java/com/droiddeck/launcher/runtime/BwrapSpawner.kt b/app/src/main/java/com/droiddeck/launcher/runtime/BwrapSpawner.kt index a5d315297..a88d4a2de 100644 --- a/app/src/main/java/com/droiddeck/launcher/runtime/BwrapSpawner.kt +++ b/app/src/main/java/com/droiddeck/launcher/runtime/BwrapSpawner.kt @@ -228,6 +228,7 @@ object BwrapSpawner { * own choice of driver (VK_ICD_FILENAMES, MESA_LOADER_DRIVER_OVERRIDE) is left alone. */ private fun gpu(rootfs: String, root: File, env: MutableMap): List? { + env["VKBRIDGE_SOCKET"]?.let { sock -> if (File(sock).exists()) return bridgeGpu(rootfs, root, env, sock) } val lib = File(rootfs, "usr/lib") val driver = File(lib, "libvulkan_freedreno.so") if (!driver.isFile || !File("/dev/kgsl-3d0").exists()) return null @@ -257,6 +258,32 @@ object BwrapSpawner { return binds } + /** + * The GPU through the Mali bridge (tools/vkbridge), for a sandbox started from a bridge + * session: the bridge ICD (it needs nothing but libc) and the server's socket, at the paths + * the session uses. Unlike Turnip on KGSL it can also present to KWin's shared-memory + * windows, so desktop apps get it too. The session's own VK_DRIVER_FILES points at the + * runtime's copy of the manifest, which the sandbox cannot see; it is replaced here. + */ + private fun bridgeGpu(rootfs: String, root: File, env: MutableMap, socket: String): List? { + val driver = File(rootfs, "usr/local/lib/vkbridge/libvulkan_droidbridge.so") + if (!driver.isFile) { Log.w(TAG, "gpu: vkbridge session but no bridge ICD in the runtime"); return null } + val binds = ArrayList() + binds.add(Bind(driver.canonicalPath, "$GPU_DIR/libvulkan_droidbridge.so")) + val sockDir = File(socket).parent ?: return null + binds.add(Bind(sockDir, sockDir)) + val icd = File(root.parentFile, "vkbridge_icd.json") + icd.writeText("{\"file_format_version\": \"1.0.0\", \"ICD\": {\"library_path\": \"$GPU_DIR/libvulkan_droidbridge.so\", \"api_version\": \"1.3.247\"}}\n") + binds.add(Bind(icd.path, "$GPU_DIR/vkbridge_icd.json")) + env["VK_DRIVER_FILES"] = "$GPU_DIR/vkbridge_icd.json" + env["VK_ICD_FILENAMES"] = "$GPU_DIR/vkbridge_icd.json" + if (!env.containsKey("MESA_LOADER_DRIVER_OVERRIDE") && !env.containsKey("GALLIUM_DRIVER")) { + env["MESA_LOADER_DRIVER_OVERRIDE"] = "zink" + env["GALLIUM_DRIVER"] = "zink" + } + return binds + } + /** * What every program in the session preloads (SessionFiles writes /etc/ld.so.preload): the * session shim - SysV shared memory for X11, the network calls Android refuses - and the diff --git a/app/src/main/java/com/droiddeck/launcher/session/SessionFiles.kt b/app/src/main/java/com/droiddeck/launcher/session/SessionFiles.kt index 6da8cfbf6..c1c57b234 100644 --- a/app/src/main/java/com/droiddeck/launcher/session/SessionFiles.kt +++ b/app/src/main/java/com/droiddeck/launcher/session/SessionFiles.kt @@ -131,6 +131,10 @@ object SessionFiles { } + listOf("libfaultreport.so", "libthunkaudit.so", "libvulkan-thunk.so").map { "x86_64/$it" to "usr/local/lib/droiddeck-fex/x86_64/$it" } val optional = (arrayOf( "usr/local/bin/gamescope" to "usr/local/bin/gamescope", + // The Mali bridge's Linux side (tools/vkbridge): the ICD, its manifest and the self-test. + "usr/local/lib/vkbridge/libvulkan_droidbridge.so" to "usr/local/lib/vkbridge/libvulkan_droidbridge.so", + "usr/local/share/vkbridge/droidbridge_icd.json" to "usr/local/share/vkbridge/droidbridge_icd.json", + "usr/local/bin/droiddeck-vkbridge-smoke" to "usr/local/bin/droiddeck-vkbridge-smoke", "usr/local/lib/droiddeck/uruntime" to "usr/local/lib/droiddeck/uruntime", "usr/local/share/licenses/uruntime/LICENSE" to "usr/local/share/licenses/uruntime/LICENSE", ) + mangoapp + msitools.map { it to it } + fexPreloads).filter { (asset, _) -> diff --git a/app/src/main/java/com/droiddeck/launcher/session/SessionPrefs.kt b/app/src/main/java/com/droiddeck/launcher/session/SessionPrefs.kt index 87537953a..f7099c874 100644 --- a/app/src/main/java/com/droiddeck/launcher/session/SessionPrefs.kt +++ b/app/src/main/java/com/droiddeck/launcher/session/SessionPrefs.kt @@ -468,6 +468,18 @@ object SessionPrefs { */ fun zinkLazy(context: Context): Boolean = prefs(context).getBoolean("zinkLazy", true) + /** + * The Mali bridge (experimental): the session's Vulkan goes through the app's bridge server to + * the phone's own driver instead of Turnip (tools/vkbridge). Only offered, and only used, on a + * GPU without Adreno's KGSL; off by default everywhere. + */ + @JvmStatic + fun vkBridge(context: Context): Boolean = prefs(context).getBoolean("vkBridge", false) + + fun setVkBridge(context: Context, on: Boolean) { + prefs(context).edit().putBoolean("vkBridge", on).apply() + } + fun setZinkLazy(context: Context, on: Boolean) { prefs(context).edit().putBoolean("zinkLazy", on).apply() } diff --git a/app/src/main/java/com/droiddeck/launcher/session/SessionService.kt b/app/src/main/java/com/droiddeck/launcher/session/SessionService.kt index 437dd5091..5aca52baa 100644 --- a/app/src/main/java/com/droiddeck/launcher/session/SessionService.kt +++ b/app/src/main/java/com/droiddeck/launcher/session/SessionService.kt @@ -351,6 +351,7 @@ class SessionService : Service() { val fastPathAt = guest.size val pulse = startAudio(guest, sessionDir) + startVkBridge(guest, sessionDir) guest.add("BL_WIDTH=" + size.first) guest.add("BL_HEIGHT=" + size.second) @@ -599,7 +600,9 @@ class SessionService : Service() { // import falls back to. One driver for every session: the driver's shader cache is keyed on // its build, and with one per mode every emulator compiled its shaders twice. val linuxDriverId = SessionPrefs.linuxDriver(this) - LinuxVulkanDriver.resolveIcdPath(this, linuxDriverId) + // With the Mali bridge on, the bridge ICD is the driver (startVkBridge); a Turnip import + // could not draw on this GPU anyway. + if (!com.droiddeck.launcher.core.DeviceSupport.vkBridge(this)) LinuxVulkanDriver.resolveIcdPath(this, linuxDriverId) ?.let { guest.add(LinuxVulkanDriver.ENV + "=" + it) } // Turnip's own debug switches, for the runtime's driver and everything on it. The file in // Downloads holds the value verbatim ("sysmem", "sysmem,deck_emu"); with nothing there, an @@ -667,6 +670,25 @@ class SessionService : Service() { .takeIf { it.isNotEmpty() }?.let { guest.add("BL_GAME_CPUS=$it") } } + /** + * The Mali bridge (Setup's experimental switch, non-Adreno GPUs only): the server that runs the + * session's Vulkan calls on the phone's own driver, started before the guest. The session + * script points the Vulkan loader at the bridge ICD when it sees BL_VKBRIDGE and runs the + * bridge's self-test into the session log first; both sides log into the session folder. + */ + private fun startVkBridge(guest: MutableList, sessionDir: File) { + if (!com.droiddeck.launcher.core.DeviceSupport.vkBridge(this)) return + // Under the files dir, which the session binds at its own path: one string for both sides. + val socket = File(filesDir, "vkbridge/server.sock") + val bridge = com.droiddeck.launcher.gpu.VkBridgeComponent(socket, File(sessionDir, "vkbridge-server.log")) + bridge.attach(this) + components.add(bridge) + guest.add("BL_VKBRIDGE=1") + guest.add("VKBRIDGE_SOCKET=" + socket.path) + guest.add("VKBRIDGE_CLIENT_LOG=" + File(sessionDir, "vkbridge-client.log").path) + Log.i(TAG, "vkbridge: on (${com.droiddeck.launcher.core.DeviceSupport.gpuName(this)}), socket $socket") + } + /** PulseAudio, and the DirectAudio relay when a path needs it; returns the daemon for suspend and resume. */ private fun startAudio(guest: MutableList, sessionDir: File): PulseAudioComponent { // PulseAudio always: the client is a native Linux program and has no other way to make a diff --git a/app/src/main/java/com/droiddeck/launcher/ui/FrontEndScreen.kt b/app/src/main/java/com/droiddeck/launcher/ui/FrontEndScreen.kt index cf3558568..c30aa5e59 100644 --- a/app/src/main/java/com/droiddeck/launcher/ui/FrontEndScreen.kt +++ b/app/src/main/java/com/droiddeck/launcher/ui/FrontEndScreen.kt @@ -124,6 +124,10 @@ class FrontEndState( val oscMode: String = SessionPrefs.OSC_AUTO, val controller: com.droiddeck.launcher.input.ControllerPrefs.Settings? = null, val phantomProcessStatus: PhantomProcessStatus = PhantomProcessStatus.NOT_APPLICABLE, + /** The GPU is an Adreno (Turnip); otherwise Setup offers the experimental Mali bridge. */ + val adreno: Boolean = true, + /** Setup's "Mali bridge (experimental)" (SessionPrefs.vkBridge). */ + val vkBridge: Boolean = false, val showPhantomGate: Boolean = false, val launcherFullscreen: Boolean = true, val animationsEnabled: Boolean = true, @@ -178,6 +182,7 @@ class FrontEndActions( val onInstallPackage: (String) -> Unit, val onRemovePackage: (String) -> Unit, val onRuntime: () -> Unit, + val onVkBridge: (Boolean) -> Unit = {}, val onFrameGenPick: (FrameGen.Mode) -> Unit, val onImportLossless: () -> Unit, val onProtons: () -> Unit, diff --git a/app/src/main/java/com/droiddeck/launcher/ui/FrontEndSetup.kt b/app/src/main/java/com/droiddeck/launcher/ui/FrontEndSetup.kt index 1b9f086f8..fe52414cd 100644 --- a/app/src/main/java/com/droiddeck/launcher/ui/FrontEndSetup.kt +++ b/app/src/main/java/com/droiddeck/launcher/ui/FrontEndSetup.kt @@ -208,8 +208,16 @@ internal fun SetupPanel( when (gpu.support) { com.droiddeck.launcher.gpu.GpuInfo.Support.TESTED -> stringResource(R.string.setup_gpu_detail, gpu.displayName(ctx), gpuName) com.droiddeck.launcher.gpu.GpuInfo.Support.UNTESTED -> stringResource(R.string.setup_gpu_untested_detail, gpu.displayName(ctx), gpu.supportText(ctx).replaceFirstChar { it.lowercase() }) - else -> stringResource(R.string.setup_gpu_unsupported_detail, gpuName) + else -> if (s.vkBridge) stringResource(R.string.setup_gpu_bridge_detail, gpuName) + else stringResource(R.string.setup_gpu_unsupported_detail, gpuName) }, + // Not an Adreno: the experimental Vulkan bridge is the one way to draw. + action = if (s.adreno) null else { { + SecondaryButton( + stringResource(if (s.vkBridge) R.string.setup_gpu_bridge_on else R.string.setup_gpu_bridge_off), + enabled = !s.sessionRunning, compact = true, onClick = { a.onVkBridge(!s.vkBridge) }, + ) + } }, ) CheckRow( when { s.busy -> CheckState.BUSY; !s.ready -> CheckState.WARN; else -> CheckState.OK }, diff --git a/app/src/main/res/values/strings.xml b/app/src/main/res/values/strings.xml index 29f00e457..f1a56410b 100644 --- a/app/src/main/res/values/strings.xml +++ b/app/src/main/res/values/strings.xml @@ -2150,4 +2150,7 @@ %1$d already in Games %1$d already in Games + Mali bridge: off + Mali bridge: on + %1$s is not an Adreno. The experimental Vulkan bridge is on: the session draws through the phone\'s own driver. Expect bugs; send the session logs. diff --git a/tools/build_local.sh b/tools/build_local.sh index 836a2c52d..e68a086f6 100755 --- a/tools/build_local.sh +++ b/tools/build_local.sh @@ -101,6 +101,7 @@ docker run --rm --platform linux/amd64 \ -o "$d/libssbs.so" tools/linuxfs/ssbs/ssbs_adapter.c -ldl aarch64-linux-gnu-strip --strip-unneeded "$d/libssbs.so" mkdir -p "$d/usr/local/bin" + tools/vkbridge/build-client-linux.sh "$d" aarch64-linux-gnu-gcc aarch64-linux-gnu-gcc -O2 -Wall -Wextra -o "$d/usr/local/bin/droiddeck-clipboard" tools/linuxfs/clipboard/clipboard.c -ldl aarch64-linux-gnu-strip --strip-unneeded "$d/usr/local/bin/droiddeck-clipboard" for script in tools/linuxfs/overlay/usr/local/bin/droiddeck-* tools/linuxfs/overlay/usr/local/bin/steam-compatibility; do diff --git a/tools/linuxfs/overlay/usr/local/bin/droiddeck-session b/tools/linuxfs/overlay/usr/local/bin/droiddeck-session index 4d5f0c04d..2adc8cd47 100755 --- a/tools/linuxfs/overlay/usr/local/bin/droiddeck-session +++ b/tools/linuxfs/overlay/usr/local/bin/droiddeck-session @@ -107,6 +107,31 @@ if [ -n "${BL_VK_DRIVER:-}" ]; then fi unset bl_icd_lib fi +# The Mali bridge (Setup's experimental switch on a non-Adreno GPU; tools/vkbridge): the app runs a +# server on the phone's own Vulkan driver and this session draws through its ICD, which replaces +# every other driver here. Checked from inside like an imported driver, and on the first pass only +# the bridge's self-test and the driver's summary go into the log, so a black screen comes with the +# reason in the same file. +if [ "${BL_VKBRIDGE:-0}" = 1 ]; then + bl_vkb_icd=/usr/local/share/vkbridge/droidbridge_icd.json + if [ -r "$bl_vkb_icd" ] && [ -r /usr/local/lib/vkbridge/libvulkan_droidbridge.so ] && [ -S "${VKBRIDGE_SOCKET:-}" ]; then + export VK_DRIVER_FILES=$bl_vkb_icd VK_ICD_FILENAMES=$bl_vkb_icd + export VKBRIDGE_SOCKET VKBRIDGE_CLIENT_LOG + # Turnip's switches mean nothing to the bridge. + unset TU_DEBUG + if [ -z "${BL_INSIDE:-}" ]; then + step "vkbridge self-test" + timeout 60 /usr/local/bin/droiddeck-vkbridge-smoke 2>&1 | sed 's/^/== vkbridge: /' + if command -v vulkaninfo >/dev/null 2>&1; then + timeout 30 vulkaninfo --summary 2>&1 | sed -n '/^Devices:/,$p' | head -40 | sed 's/^/== vulkaninfo: /' + fi + fi + echo "== vulkan driver: Mali bridge ($bl_vkb_icd, server at $VKBRIDGE_SOCKET)" + else + echo "== vulkan driver: Mali bridge requested but NOT usable (icd $bl_vkb_icd, socket ${VKBRIDGE_SOCKET:-unset}); this GPU will show a black screen" + fi + unset bl_vkb_icd +fi # The app's gamescope build (tools/gamescope) asks for realtime-priority Vulkan queues on this # switch instead of on CAP_SYS_NICE, which proot never has; it falls back to normal priority # where the driver refuses, and the runtime's own build ignores it. On KGSL Turnip (Mesa 26.2) it diff --git a/tools/vkbridge/build-client-linux.sh b/tools/vkbridge/build-client-linux.sh new file mode 100755 index 000000000..81d37d59d --- /dev/null +++ b/tools/vkbridge/build-client-linux.sh @@ -0,0 +1,26 @@ +#!/bin/bash +# Builds the Linux side of the bridge for the runtime (glibc, aarch64): +# tools/vkbridge/build-client-linux.sh [cc] +# Produces, under the asset dir (staged into the runtime by SessionFiles): +# usr/local/lib/vkbridge/libvulkan_droidbridge.so the Vulkan ICD +# usr/local/share/vkbridge/droidbridge_icd.json its manifest +# usr/local/bin/droiddeck-vkbridge-smoke the session-start self-test +set -euo pipefail +d=$1 +cc=${2:-aarch64-linux-gnu-gcc} +strip=${STRIP:-${cc%gcc}strip} +here=$(cd "$(dirname "$0")" && pwd) +inc="-I$here/third_party/Vulkan-Headers-1.3.247/include -I$here/common -I$here/common/gen" +mkdir -p "$d/usr/local/lib/vkbridge" "$d/usr/local/share/vkbridge" "$d/usr/local/bin" +"$cc" -O2 -fPIC -shared -fvisibility=hidden -DVKB_CLIENT -Wall -Wno-unused-parameter -Wno-missing-field-initializers \ + $inc -I"$here/client" -I"$here/client/compat" -pthread \ + -Wl,--no-undefined -Wl,-soname,libvulkan_droidbridge.so \ + -o "$d/usr/local/lib/vkbridge/libvulkan_droidbridge.so" \ + "$here"/client/*.c "$here/common/vkb_wire.c" "$here/common/gen/vkb_gen_structs.c" "$here/common/gen/vkb_gen_client.c" -ldl +"$strip" --strip-unneeded "$d/usr/local/lib/vkbridge/libvulkan_droidbridge.so" +"$cc" -O2 -Wall $inc -I"$here/tests" -o "$d/usr/local/bin/droiddeck-vkbridge-smoke" "$here/tests/smoke.c" -ldl +"$strip" --strip-unneeded "$d/usr/local/bin/droiddeck-vkbridge-smoke" +cat > "$d/usr/local/share/vkbridge/droidbridge_icd.json" < +# The output is an executable named like a library (libvkbridge_server.so) so that Android +# extracts it into the native library directory, the one place an app may exec from. +set -euo pipefail +ndk=$1 +out=$2/arm64-v8a +here=$(cd "$(dirname "$0")" && pwd) +srv=$(cd "$here/../../app/src/main/cpp/vkbridge" && pwd) +cc=$(ls -d "$ndk"/toolchains/llvm/prebuilt/*/bin/aarch64-linux-android26-clang | head -1) +[ -x "$cc" ] || { echo "no NDK clang under $ndk" >&2; exit 1; } +mkdir -p "$out" +"$cc" -O2 -g0 -fPIE -pie -Wall -Wno-unused-parameter -Wno-missing-field-initializers \ + -I"$here/third_party/Vulkan-Headers-1.3.247/include" -I"$here/common" -I"$here/common/gen" -I"$srv" \ + -Wl,-z,max-page-size=16384 -Wl,--build-id=none \ + -o "$out/libvkbridge_server.so" \ + "$srv"/*.c "$here/common/vkb_wire.c" "$here/common/gen/vkb_gen_structs.c" "$here/common/gen/vkb_gen_server.c" \ + -ldl -llog -lm +"$(dirname "$cc")/llvm-strip" --strip-unneeded "$out/libvkbridge_server.so" +echo "built $out/libvkbridge_server.so"