From dae36b0e679b8bd55b079614ad698ab6b112d06b Mon Sep 17 00:00:00 2001 From: Ahmad Sayed Alsayed Ebrahim Date: Wed, 14 Oct 2026 17:06:11 +0300 Subject: [PATCH] Mali bridge sessions: Setup switch, server, session wiring On a GPU without KGSL, Setup offers an experimental Mali bridge switch (off by default; ignored on Adreno). With it on, the session starts the bridge server, points the Vulkan loader at the bridge ICD, names Mali's device as the stand-in render node, runs the bridge self-test into the session log, and caps vkd3d-proton's feature level at 12_0. Flatpak sandboxes get the bridge ICD and socket. The DRM preload falls back to flock in a bridge session when kcmp is refused, and a clock/thermal log is kept beside the bridge logs. --- .../droiddeck/launcher/FrontEndActivity.kt | 9 +- .../droiddeck/launcher/core/DeviceSupport.kt | 5 + .../launcher/gpu/ClockLogComponent.kt | 108 ++++++++++++++++++ .../droiddeck/launcher/gpu/TurnipDriver.java | 4 + .../launcher/gpu/VkBridgeComponent.kt | 61 ++++++++++ .../droiddeck/launcher/gpu/VkBridgeNative.kt | 49 ++++++++ .../launcher/runtime/BwrapSpawner.kt | 23 ++++ .../launcher/runtime/LinuxRuntime.java | 31 ++++- .../launcher/session/SessionFiles.kt | 3 + .../launcher/session/SessionPrefs.kt | 7 ++ .../launcher/session/SessionService.kt | 23 +++- .../droiddeck/launcher/ui/FrontEndScreen.kt | 3 + .../droiddeck/launcher/ui/FrontEndSetup.kt | 9 +- app/src/main/res/values/strings.xml | 3 + .../overlay/usr/local/bin/droiddeck-game-env | 11 ++ .../overlay/usr/local/bin/droiddeck-session | 36 ++++++ tools/linuxfs/preload/drm.c | 40 +++++-- tools/tests/test_game_environment.py | 9 ++ 18 files changed, 419 insertions(+), 15 deletions(-) create mode 100644 app/src/main/java/com/droiddeck/launcher/gpu/ClockLogComponent.kt create mode 100644 app/src/main/java/com/droiddeck/launcher/gpu/VkBridgeComponent.kt create mode 100644 app/src/main/java/com/droiddeck/launcher/gpu/VkBridgeNative.kt diff --git a/app/src/main/java/com/droiddeck/launcher/FrontEndActivity.kt b/app/src/main/java/com/droiddeck/launcher/FrontEndActivity.kt index a80e3c5d61..2d027f267e 100644 --- a/app/src/main/java/com/droiddeck/launcher/FrontEndActivity.kt +++ b/app/src/main/java/com/droiddeck/launcher/FrontEndActivity.kt @@ -148,6 +148,8 @@ class FrontEndActivity : 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) @@ -809,6 +811,7 @@ class FrontEndActivity : ComponentActivity() { FrontEndScreen( FrontEndState( installed = installed, ready = ready, available = available?.version, removalPending = removalPending, runtimeActionsBlocked = runtimeChangesBlocked(), + vkBridge = vkBridge, adreno = adrenoGpu, shortcutPicker = shortcutPicker, shortcutLibraryScanning = shortcutLibraryScanning, gameSyncFolder = gameSyncFolder, @@ -949,6 +952,7 @@ class FrontEndActivity : 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) @@ -2072,6 +2076,7 @@ class FrontEndActivity : 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) @@ -2189,7 +2194,7 @@ class FrontEndActivity : ComponentActivity() { Thread({ checkCatalog() }, "catalog").start() return } - 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) } @@ -2204,7 +2209,7 @@ class FrontEndActivity : 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 325ed7d43d..1036f5c06e 100644 --- a/app/src/main/java/com/droiddeck/launcher/core/DeviceSupport.kt +++ b/app/src/main/java/com/droiddeck/launcher/core/DeviceSupport.kt @@ -9,6 +9,11 @@ object DeviceSupport { fun adreno(): Boolean = File("/sys/class/kgsl/kgsl-3d0").exists() || File("/vendor/lib64/hw/vulkan.adreno.so").exists() + fun vkBridge(context: Context): Boolean = + !adreno() && com.droiddeck.launcher.session.SessionPrefs.vkBridge(context) + + fun canDraw(context: Context): Boolean = adreno() || vkBridge(context) + fun gpuName(context: Context): String { val soc = if (Build.VERSION.SDK_INT >= 31) Build.SOC_MODEL.takeIf { it.isNotBlank() && it != Build.UNKNOWN } else null return soc?.let { "$it (${Build.HARDWARE})" } ?: Build.HARDWARE.ifBlank { context.getString(R.string.gpu_this_gpu) } diff --git a/app/src/main/java/com/droiddeck/launcher/gpu/ClockLogComponent.kt b/app/src/main/java/com/droiddeck/launcher/gpu/ClockLogComponent.kt new file mode 100644 index 0000000000..8385deaafa --- /dev/null +++ b/app/src/main/java/com/droiddeck/launcher/gpu/ClockLogComponent.kt @@ -0,0 +1,108 @@ +package com.droiddeck.launcher.gpu + +import android.content.Context +import android.os.Build +import android.os.PowerManager +import android.util.Log +import com.droiddeck.launcher.core.SessionPart +import java.io.File +import java.io.FileWriter +import java.text.SimpleDateFormat +import java.util.Date +import java.util.Locale + +class ClockLogComponent(private val logFile: File) : SessionPart() { + @Volatile private var running = false + private var thread: Thread? = null + + override fun start() { + running = true + thread = Thread({ run() }, "clock-log").apply { isDaemon = true; start() } + } + + override fun stop() { + running = false + thread?.interrupt() + thread = null + } + + private fun run() { + val policies = File("/sys/devices/system/cpu/cpufreq").listFiles { f -> f.name.startsWith("policy") } + ?.sortedBy { it.name.removePrefix("policy").toIntOrNull() ?: 0 } ?: emptyList() + val gpuCandidates = gpuSources() + val gpu = gpuCandidates.firstOrNull { !it.startsWith("/proc/") && firstNumber(it) != null } + val power = app().getSystemService(Context.POWER_SERVICE) as? PowerManager + val time = SimpleDateFormat("HH:mm:ss", Locale.US) + try { + FileWriter(logFile, true).use { w -> + w.write("== clocks: ${Build.MANUFACTURER} ${Build.MODEL} (${Build.HARDWARE}), every ${PERIOD_MS / 1000}s\n") + w.write("cpu policies: ${policies.joinToString { p -> p.name + " " + (File(p, "related_cpus").readTextOrNull()?.trim() ?: "?") }}\n") + for (source in gpuCandidates) { + val f = File(source) + val state = when { + !f.exists() -> continue + firstNumber(source) != null -> "readable" + else -> "refused" + } + w.write("gpu source $source: $state\n") + } + w.write("gpu clock from: ${gpu ?: "nothing readable"}\n") + w.flush() + while (running && logFile.length() < MAX_BYTES) { + val line = StringBuilder(time.format(Date())) + for (p in policies) { + val cur = firstNumber(File(p, "scaling_cur_freq").path) + val max = firstNumber(File(p, "scaling_max_freq").path) + val hw = firstNumber(File(p, "cpuinfo_max_freq").path) + line.append(" ${p.name.removePrefix("policy").let { "p$it" }} ${mhz(cur)}/${mhz(max)}") + if (hw != null && max != null && max < hw) line.append("(of ${mhz(hw)})") + } + gpu?.let { line.append(" | gpu ${mhz(firstNumber(it))} MHz") } + if (power != null && Build.VERSION.SDK_INT >= 29) { + line.append(" | thermal ${power.currentThermalStatus}") + if (Build.VERSION.SDK_INT >= 30) { + val h = power.getThermalHeadroom(10) + if (!h.isNaN()) line.append(String.format(Locale.US, " headroom %.2f", h)) + } + } + w.write(line.append('\n').toString()) + w.flush() + try { Thread.sleep(PERIOD_MS) } catch (e: InterruptedException) { break } + } + } + } catch (e: Exception) { + Log.w(TAG, "clock log stopped: $e") + } + } + + companion object { + private const val TAG = "SessionService" + private const val PERIOD_MS = 2000L + private const val MAX_BYTES = 4L shl 20 + + private fun gpuSources(): List { + val list = mutableListOf( + "/sys/kernel/ged/hal/current_freqency", "/sys/kernel/ged/hal/current_frequency", + "/proc/gpufreqv2/gpufreq_status", "/proc/gpufreq/gpufreq_var_dump", + "/sys/kernel/gpu/gpu_clock", "/sys/class/misc/mali0/device/cur_freq", + "/sys/class/misc/mali0/device/clock", + ) + File("/sys/class/devfreq").list()?.sorted()?.forEach { node -> + if (node.contains("mali", true) || node.contains("gpu", true)) list.add("/sys/class/devfreq/$node/cur_freq") + } + return list.distinct() + } + + private fun File.readTextOrNull(): String? = runCatching { readText() }.getOrNull() + + private fun firstNumber(path: String): Long? = + runCatching { Regex("\\d+").find(File(path).readText())?.value?.toLong() }.getOrNull() + + private fun mhz(raw: Long?): String = when { + raw == null -> "?" + raw > 10_000_000 -> (raw / 1_000_000).toString() + raw > 10_000 -> (raw / 1_000).toString() + else -> raw.toString() + } + } +} 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 9978409c5f..46b09e1e81 100644 --- a/app/src/main/java/com/droiddeck/launcher/gpu/TurnipDriver.java +++ b/app/src/main/java/com/droiddeck/launcher/gpu/TurnipDriver.java @@ -284,6 +284,10 @@ public final class TurnipDriver { } String quest = QuestExperimental.INSTANCE.defaultAndroidDriver(); if (quest != null) return quest; + if (com.droiddeck.launcher.core.DeviceSupport.INSTANCE.vkBridge(context)) { + Log.i(TAG, "Mali bridge: the compositor uses the system Vulkan driver"); + return null; + } int model = GpuInfo.Companion.detect().getModel(); Log.i(TAG, "gpu model: " + (model == 0 ? "unknown" : model)); return chooseByModel(model, android.os.Build.VERSION.SDK_INT); 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 0000000000..599e5e5d8b --- /dev/null +++ b/app/src/main/java/com/droiddeck/launcher/gpu/VkBridgeComponent.kt @@ -0,0 +1,61 @@ +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 + +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() + val cacheDir = File(app().cacheDir, "vkbridge-pipelines").apply { mkdirs() } + if (VkBridgeNative.start(app(), socket, logFile, cacheDir)) { + Log.i(TAG, "server ready in the app's process at $socket") + return + } + socket.delete() + exited = false + val cmd = listOf(binary.absolutePath, "--socket", socket.absolutePath, "--log", logFile.absolutePath, + "--cache-dir", cacheDir.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) }) + 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") + if (!socket.exists() && VkBridgeNative.start(app(), socket, logFile, cacheDir)) Log.i(TAG, "server ready in the app's process at $socket") + } + + override fun stop() { + if (pid > 0) { + Process.killProcess(pid) + pid = -1 + } + if (!VkBridgeNative.serving) socket.delete() + } + + override fun suspendPid(): Int = pid + + companion object { + private const val TAG = "VkBridge" + const val BINARY = "libvkbridge_server.so" + 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/gpu/VkBridgeNative.kt b/app/src/main/java/com/droiddeck/launcher/gpu/VkBridgeNative.kt new file mode 100644 index 0000000000..97efa7bed8 --- /dev/null +++ b/app/src/main/java/com/droiddeck/launcher/gpu/VkBridgeNative.kt @@ -0,0 +1,49 @@ +package com.droiddeck.launcher.gpu + +import android.content.Context +import android.content.pm.ApplicationInfo +import android.util.Log +import java.io.File + +object VkBridgeNative { + private const val TAG = "VkBridge" + + @Volatile private var loaded: Boolean? = null + + private fun load(context: Context): Boolean { + loaded?.let { return it } + val ok = try { + val dev = File(context.filesDir, "vkbridge/dev/libvkbridge_jni.so") + val debuggable = context.applicationInfo.flags and ApplicationInfo.FLAG_DEBUGGABLE != 0 + if (debuggable && dev.isFile) { + Log.w(TAG, "in-app server from the development override $dev") + System.load(dev.absolutePath) + } else { + System.loadLibrary("vkbridge_jni") + } + true + } catch (e: Throwable) { + Log.w(TAG, "in-app server unavailable: $e") + false + } + loaded = ok + return ok + } + + @Volatile var serving = false + private set + + fun start(context: Context, socket: File, log: File, cacheDir: File): Boolean { + if (!load(context)) return false + val ok = try { + nativeStart(socket.absolutePath, log.absolutePath, cacheDir.absolutePath) == 1 + } catch (e: Throwable) { + Log.w(TAG, "in-app server failed to start: $e") + false + } + if (ok) serving = true + return ok + } + + @JvmStatic private external fun nativeStart(socket: String, log: String, cacheDir: String): Int +} 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 81fabd7f7d..c6e1d802b2 100644 --- a/app/src/main/java/com/droiddeck/launcher/runtime/BwrapSpawner.kt +++ b/app/src/main/java/com/droiddeck/launcher/runtime/BwrapSpawner.kt @@ -189,6 +189,7 @@ object BwrapSpawner { private const val GPU_DIR = "/run/droiddeck-gpu" 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 @@ -213,6 +214,28 @@ object BwrapSpawner { return binds } + 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") + val api = runCatching { + JSONObject(File(rootfs, "usr/local/share/vkbridge/droidbridge_icd.json").readText()).getJSONObject("ICD").getString("api_version") + }.getOrNull() ?: run { Log.w(TAG, "gpu: vkbridge session but the runtime's bridge manifest is unreadable"); return null } + icd.writeText("{\"file_format_version\": \"1.0.0\", \"ICD\": {\"library_path\": \"$GPU_DIR/libvulkan_droidbridge.so\", \"api_version\": \"$api\"}}\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 + } + private fun preload(session: List, rootfs: String, env: MutableMap): List { val libs = FileUtils.readString(File(rootfs, "etc/ld.so.preload"))?.lines() ?.map { it.trim() }?.filter { it.startsWith("/") && File(rootfs + it).isFile } ?: return emptyList() diff --git a/app/src/main/java/com/droiddeck/launcher/runtime/LinuxRuntime.java b/app/src/main/java/com/droiddeck/launcher/runtime/LinuxRuntime.java index d02fdf0c2f..49c4724ee0 100644 --- a/app/src/main/java/com/droiddeck/launcher/runtime/LinuxRuntime.java +++ b/app/src/main/java/com/droiddeck/launcher/runtime/LinuxRuntime.java @@ -280,10 +280,32 @@ public final class LinuxRuntime { return false; } + private static final String MALI_DEVICE = "/dev/mali0"; + + public static String gpuStandIn(Context context) { + if (new File(KGSL_DEVICE).exists()) return KGSL_DEVICE; + if (com.droiddeck.launcher.core.DeviceSupport.INSTANCE.vkBridge(context) && new File(MALI_DEVICE).exists()) return MALI_DEVICE; + return null; + } + + public static String deviceNumbers(String path) { + try { + long dev = Os.stat(path).st_rdev; + long major = ((dev >> 8) & 0xfff) | ((dev >> 32) & ~0xfffL); + long minor = (dev & 0xff) | ((dev >> 12) & ~0xffL); + return major + ":" + minor; + } catch (ErrnoException e) { + return null; + } + } + private static void bindGpuNode(Context context, List cmd) { + String standIn = gpuStandIn(context); + if (standIn == null) return; + boolean kgsl = standIn.equals(KGSL_DEVICE); StructStat st; try { - st = Os.stat(KGSL_DEVICE); + st = Os.stat(standIn); } catch (ErrnoException e) { return; } @@ -303,13 +325,14 @@ public final class LinuxRuntime { Files.write(new File(drm, "dev").toPath(), (major + ":" + minor + "\n").getBytes(StandardCharsets.UTF_8)); Files.write(new File(device, "uevent").toPath(), - "DRIVER=kgsl-3d0\nMODALIAS=platform:kgsl-3d0\n".getBytes(StandardCharsets.UTF_8)); + (kgsl ? "DRIVER=kgsl-3d0\nMODALIAS=platform:kgsl-3d0\n" : "DRIVER=mali\nMODALIAS=platform:mali\n") + .getBytes(StandardCharsets.UTF_8)); File subsystem = new File(device, "subsystem"); if (!Files.isSymbolicLink(subsystem.toPath())) { Os.symlink("/sys/bus/platform", subsystem.getPath()); } File driver = new File(device, "driver"); - if (!Files.isSymbolicLink(driver.toPath())) { + if (kgsl && !Files.isSymbolicLink(driver.toPath())) { Os.symlink("/sys/bus/platform/drivers/msm_drm", driver.getPath()); } } catch (IOException | ErrnoException e) { @@ -317,7 +340,7 @@ public final class LinuxRuntime { } bind(cmd, new File(base, "sys").getPath() + ":/sys/dev/char"); bind(cmd, dri.getPath() + ":/dev/dri"); - bind(cmd, KGSL_DEVICE + ":/dev/dri/" + node); + bind(cmd, standIn + ":/dev/dri/" + node); bindDrmClass(base, cmd, node, major + ":" + minor); } 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 d9c59b1b88..6979ff3b3f 100644 --- a/app/src/main/java/com/droiddeck/launcher/session/SessionFiles.kt +++ b/app/src/main/java/com/droiddeck/launcher/session/SessionFiles.kt @@ -154,6 +154,9 @@ object SessionFiles { "usr/local/bin/gamescope" to "usr/local/bin/gamescope", // The gamescope pack carries its own WSI layer (patch 0117); it replaces the runtime's stock copy. "usr/lib/libVkLayer_FROG_gamescope_wsi_aarch64.so" to "usr/lib/libVkLayer_FROG_gamescope_wsi_aarch64.so", + "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/lib/droiddeck-pipewire.tzst" to "usr/local/lib/droiddeck-pipewire.tzst", "usr/local/share/licenses/uruntime/LICENSE" to "usr/local/share/licenses/uruntime/LICENSE", 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 8ffaacd563..104c3572d8 100644 --- a/app/src/main/java/com/droiddeck/launcher/session/SessionPrefs.kt +++ b/app/src/main/java/com/droiddeck/launcher/session/SessionPrefs.kt @@ -596,6 +596,13 @@ object SessionPrefs { fun zinkLazy(context: Context): Boolean = prefs(context).getBoolean("zinkLazy", true) + @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 be9795042a..7dcf5a3616 100644 --- a/app/src/main/java/com/droiddeck/launcher/session/SessionService.kt +++ b/app/src/main/java/com/droiddeck/launcher/session/SessionService.kt @@ -496,6 +496,7 @@ class SessionService : Service() { components.add(encoder) guest.add("BL_VENC_SOCKET=" + encoder.socket.absolutePath) } + startVkBridge(guest, sessionDir) guest.add("BL_WIDTH=" + size.first) guest.add("BL_HEIGHT=" + size.second) @@ -760,7 +761,7 @@ class SessionService : Service() { ?: SessionPrefs.androidDriver(this), linuxDriverId, ) - LinuxVulkanDriver.resolveIcdPath(this, linuxDriverId) + if (!com.droiddeck.launcher.core.DeviceSupport.vkBridge(this)) LinuxVulkanDriver.resolveIcdPath(this, linuxDriverId) ?.let { guest.add(LinuxVulkanDriver.ENV + "=" + it) } val tuOverride = tuDebugOverride() val tuDriver = sysmemDriver(linuxDriverId) @@ -814,6 +815,26 @@ class SessionService : Service() { private fun noSteamGame(): Boolean = SessionState.mode == MODE_RUN && SessionState.program in setOf(NoSteamLaunch.PROTON_RUN, NoSteamLaunch.EPIC, NoSteamLaunch.BATTLENET) + private fun startVkBridge(guest: MutableList, sessionDir: File) { + if (!com.droiddeck.launcher.core.DeviceSupport.vkBridge(this)) return + 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) + com.droiddeck.launcher.gpu.ClockLogComponent(File(sessionDir, "vkbridge-clocks.log")).let { + it.attach(this) + components.add(it) + } + guest.add("BL_VKBRIDGE=1") + guest.add("VKBRIDGE_SOCKET=" + socket.path) + guest.add("VKBRIDGE_CLIENT_LOG=" + File(sessionDir, "vkbridge-client.log").path) + LinuxRuntime.gpuStandIn(this)?.let { node -> + guest.add("BL_DRM_STANDIN=$node") + LinuxRuntime.deviceNumbers(node)?.let { guest.add("VKBRIDGE_DRM_RENDER=$it") } + } + Log.i(TAG, "vkbridge: on (${com.droiddeck.launcher.core.DeviceSupport.gpuName(this)}), socket $socket") + } + private fun startAudio(guest: MutableList, sessionDir: File, directAudioPack: Boolean): PulseAudioComponent { val wantsDirectAudio = directAudioPack && (SessionState.mode == MODE_STEAM || SessionState.mode == MODE_DESKTOP || noSteamGame()) && 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 4df261e8d2..2391044fa3 100644 --- a/app/src/main/java/com/droiddeck/launcher/ui/FrontEndScreen.kt +++ b/app/src/main/java/com/droiddeck/launcher/ui/FrontEndScreen.kt @@ -137,6 +137,8 @@ class FrontEndState( val oscMode: String = SessionPrefs.OSC_AUTO, val controller: com.droiddeck.launcher.input.ControllerPrefs.Settings? = null, val phantomProcessStatus: PhantomProcessStatus = PhantomProcessStatus.NOT_APPLICABLE, + val adreno: Boolean = true, + val vkBridge: Boolean = false, val showPhantomGate: Boolean = false, val orientation: Int = android.content.pm.ActivityInfo.SCREEN_ORIENTATION_SENSOR_LANDSCAPE, val launcherOrientation: Int = android.content.pm.ActivityInfo.SCREEN_ORIENTATION_USER, @@ -193,6 +195,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 43926aa6b1..5db7900c66 100644 --- a/app/src/main/java/com/droiddeck/launcher/ui/FrontEndSetup.kt +++ b/app/src/main/java/com/droiddeck/launcher/ui/FrontEndSetup.kt @@ -235,9 +235,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) }, divider = divider, + 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) }, + ) + } }, ) } val runtimeCheck: @Composable (Boolean) -> Unit = { divider -> diff --git a/app/src/main/res/values/strings.xml b/app/src/main/res/values/strings.xml index 840e26ebb6..ebf2ff2bf3 100644 --- a/app/src/main/res/values/strings.xml +++ b/app/src/main/res/values/strings.xml @@ -3226,4 +3226,7 @@ Cloud settings Xbox Cloud Gaming Game Pass + 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/linuxfs/overlay/usr/local/bin/droiddeck-game-env b/tools/linuxfs/overlay/usr/local/bin/droiddeck-game-env index a854bb1d7b..0bab42b210 100755 --- a/tools/linuxfs/overlay/usr/local/bin/droiddeck-game-env +++ b/tools/linuxfs/overlay/usr/local/bin/droiddeck-game-env @@ -371,6 +371,14 @@ def apply_config(env, config, app_id, fixes=None): return result +def bridge_feature_level(env): + if env.get("BL_VKBRIDGE") != "1" or env.get("VKD3D_FEATURE_LEVEL") not in ("12_1", "12_2"): + return None + was = env["VKD3D_FEATURE_LEVEL"] + env["VKD3D_FEATURE_LEVEL"] = "12_0" + return "Mali bridge: VKD3D_FEATURE_LEVEL %s capped at 12_0 (no ray tracing or mesh shaders)" % was + + def sync_config(config, app_id): games = config.get("games", {}) return { @@ -613,6 +621,9 @@ def main(): if mic_enabled == "0": env["BANNER_AUDIO_DIRECT_MIC"] = "0" env = vram_cap(env) + note = bridge_feature_level(env) + if note: + print("droiddeck-game-env: " + note, file=sys.stderr) env = force_ssbs(command, env) game_cores(env) try: diff --git a/tools/linuxfs/overlay/usr/local/bin/droiddeck-session b/tools/linuxfs/overlay/usr/local/bin/droiddeck-session index 0f99643ee3..37eef3b4db 100755 --- a/tools/linuxfs/overlay/usr/local/bin/droiddeck-session +++ b/tools/linuxfs/overlay/usr/local/bin/droiddeck-session @@ -114,6 +114,32 @@ if [ -n "${BL_VK_DRIVER:-}" ]; then fi unset bl_icd_lib fi +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 + if [ -r /root/.vkbridge-env ]; then + while IFS='=' read -r _k _v; do + case "$_k" in VKBRIDGE_*|BL_VKBRIDGE_*) export "$_k=$_v" ;; esac + done < /root/.vkbridge-env + [ -z "${BL_INSIDE:-}" ] && echo "== vkbridge: development settings from /root/.vkbridge-env: $(cut -d= -f1 /root/.vkbridge-env | tr '\n' ' ')" + fi + export VKD3D_FEATURE_LEVEL=${VKD3D_FEATURE_LEVEL:-12_0} + 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 export GAMESCOPE_FORCE_VULKAN_REALTIME=${BL_GAMESCOPE_REALTIME:-0} start_agent() { @@ -955,6 +981,16 @@ BUSCONF _bl_cef=(-cef-disable-gpu) _bl_ui=(-nobigpicture) fi + if [ "${BL_VKBRIDGE:-0}" = 1 ]; then + if [ "${BL_VKBRIDGE_CEF_GPU:-1}" = 0 ]; then + _bl_cef=(-cef-disable-gpu -cef-disable-gpu-compositing) + echo "== steam: browser UI in software (Mali bridge)" + elif [ "${_bl_cef[0]}" = -cef-force-gpu ]; then + _bl_cef=(-cef-force-gpu -cef-use-gl=angle -cef-use-angle="${BL_VKBRIDGE_CEF_ANGLE:-vulkan}") + fi + [ "${BL_VKBRIDGE_CEF_LOG:-0}" = 1 ] && _bl_cef+=(-cef-enable-logging=stderr -cef-v=1) + [ -n "${BL_VKBRIDGE_CEF_EXTRA:-}" ] && read -r -a _bl_cef_extra <<<"$BL_VKBRIDGE_CEF_EXTRA" && _bl_cef+=("${_bl_cef_extra[@]}") + fi if [ "${BL_STEAM_UI:-}" != desktop ]; then if [ "$steam_x64" = 0 ] || [ "${BL_X64_DECK:-1}" != 0 ]; then _bl_ui+=(-steamdeck -steamos3) diff --git a/tools/linuxfs/preload/drm.c b/tools/linuxfs/preload/drm.c index 101512387f..37784c3d94 100644 --- a/tools/linuxfs/preload/drm.c +++ b/tools/linuxfs/preload/drm.c @@ -5,6 +5,7 @@ #include #include #include +#include #include #include #include @@ -34,7 +35,8 @@ static int is_kgsl(int fd) { struct stat st; pthread_mutex_lock(&lock); if (kgsl_state == 0) { - kgsl_state = stat("/dev/kgsl-3d0", &st) == 0 ? 1 : -1; + const char *standin = getenv("BL_DRM_STANDIN"); + kgsl_state = stat("/dev/kgsl-3d0", &st) == 0 || (standin && *standin && stat(standin, &st) == 0) ? 1 : -1; kgsl_dev = st.st_rdev; } pthread_mutex_unlock(&lock); @@ -49,18 +51,42 @@ static void *real(const char *name) { return fn; } +static int same_by_flock(int a, int b) { + struct stat sa, sb; + if (fstat(a, &sa) || fstat(b, &sb) || sa.st_dev != sb.st_dev || sa.st_ino != sb.st_ino || + flock(a, LOCK_EX | LOCK_NB)) { + return 0; + } + int same = flock(b, LOCK_EX | LOCK_NB) == 0; + flock(a, LOCK_UN); + return same; +} + static int same_file_description(int a, int b) { if (a == b) { return 1; } -#ifdef SYS_kcmp int saved_errno = errno; - long ret = syscall(SYS_kcmp, getpid(), getpid(), 0 , a, b); - errno = saved_errno; - return ret == 0; -#else - return 0; + int ret = -1; +#ifdef SYS_kcmp + static int kcmp_missing; + if (!kcmp_missing) { + long k = syscall(SYS_kcmp, getpid(), getpid(), 0, a, b); + if (k >= 0) { + ret = k == 0; + } else if (errno == ENOSYS || errno == EPERM) { + kcmp_missing = 1; + } else { + ret = 0; + } + } #endif + if (ret < 0) { + const char *standin = getenv("BL_DRM_STANDIN"); + ret = standin && *standin ? same_by_flock(a, b) : 0; + } + errno = saved_errno; + return ret; } static int find_handle_locked(int fd, uint32_t handle) { diff --git a/tools/tests/test_game_environment.py b/tools/tests/test_game_environment.py index b4bc05aada..c6aadd0cd1 100644 --- a/tools/tests/test_game_environment.py +++ b/tools/tests/test_game_environment.py @@ -192,6 +192,15 @@ class GameEnvironmentTest(unittest.TestCase): self.assertEqual(evaluate(), (0, 2)) self.assertEqual(evaluate("changed"), (0, 3)) + def test_the_mali_bridge_caps_the_vkd3d_feature_level(self): + bridge = {"BL_VKBRIDGE": "1", "VKD3D_FEATURE_LEVEL": "12_2"} + self.assertIn("capped", MODULE["bridge_feature_level"](bridge)) + self.assertEqual(bridge["VKD3D_FEATURE_LEVEL"], "12_0") + for env in ({"BL_VKBRIDGE": "1", "VKD3D_FEATURE_LEVEL": "11_1"}, {"VKD3D_FEATURE_LEVEL": "12_2"}, {"BL_VKBRIDGE": "1"}): + before = dict(env) + self.assertIsNone(MODULE["bridge_feature_level"](env)) + self.assertEqual(env, before) + def test_profile_precedence_and_unset(self): env = {"KEEP": "inherited", "REMOVE": "inherited", "CUSTOM": "launch option"} config = {"version": 1, "shared": {"CUSTOM": "shared"}, "games": {"42": {"REMOVE": None, "CUSTOM": "game", "EMPTY": ""}}}