From eadebc46d57b6fed3bbf4a2a39edfbbe61877fa4 Mon Sep 17 00:00:00 2001 From: MaxsTechReview Date: Sat, 10 Oct 2026 19:00:33 -0400 Subject: [PATCH 1/9] Performance: idle front end, proot stops, launch-time passes and log collection (#529) * Front end: draw the capsule wall without clipping it every frame The tilted wall clipped each capsule to a rounded rect and recomposed its columns on every drift step, and a rotated rounded clip is rasterised in software on the render threads: the idle main page held about 1.7 cores. The art is now loaded at the capsule's size with its corners already rounded, each column draws its capsules itself in one layer moved by the drift, and the drift advances at most every 15 ms. The idle page takes about a third of a core. * libfakeinput: let calls on descriptors it does not serve skip its lock Every read, write, ioctl, close and poll of every process in a Proton session went through the controller lock and the three map lookups, Wine's wineserver pipes and the game's files alike. A bitmap of the descriptors the maps hold, set before one is handed out and cleared when it is closed, lets everything else go straight to the kernel. * Pad motion: ask the display for its rotation four times a second The rotation was looked up for every sensor reading, every 2 ms, and cost more than the rest of the reading; it is now refreshed every 250 ms, and the readings no longer allocate pairs. * Session: keep the library passes out of a game's launch The redist seeder stamped each prefix with the checksum of the whole set of names, which differs between the session's pass and the game launch's (the game's own names are added), so every launch re-appended the markers to every prefix in the library while the game loaded. Each prefix's marker now lists the names it was given and only the missing ones are added. The beat's seed and compatibility passes, and the Lossless Scaling ownership probe (which loads steamclient.so), also wait while a wineserver runs: a launch rewrites the manifest and made them due at exactly that moment. The game's own launch seeds its prefix regardless. * Agent: keep the focus watcher's X connection open while nothing changes The connect timeout stayed on the socket, so with no property change the read timed out, and the watcher dropped the connection, reconnected and took a fresh snapshot every few seconds. * Game environment: start Cyberpunk 2077 without REDlauncher The prelauncher opens REDlauncher, a Qt WebEngine window that hands over to the game half a minute later and then stays up beside it, well over a core busy for as long as the game runs; its own --launcher-skip started the game twice. The game's executable is started directly instead. * netif: answer Wine's network driver from a reading of the link Mortal Kombat X has Wine's network driver enumerate every interface, address and route table hundreds of times a second. Each enumeration read /etc/droiddeck-net several times, asked the kernel for its interface dump again (a netlink socket bound under proot, refused each time) and looked the real functions up with dlsym. The link file is now read at most once a second, a refused dump is not asked for again within that second, and the real functions are looked up once. * Fast path: create memfds without a stop in proot proot looks at a memfd's name only to refuse the few that are then executed or locked; every other memfd_create is now issued from the trampoline. The session's /proc/net and status copies made one per read, a stop each. Without memfd in the kernel the call still goes to proot's ashmem. * Logs: run each redaction rule only on a line that could match it A session's end copies some 70 MB of the Steam client's logs and puts every line through all twenty-odd rules, most of a minute of a core on the phone after every session. Each rule now runs only on a line holding what it cannot match without: its keyword, the five separators of a MAC, the four dashes of a GUID, a long enough hex or token run, the learned account or address text. Lines with non-ASCII text still meet every case-insensitive rule. Over 895,000 lines of real client logs, with the device's accounts and addresses learned, the output is identical and the pass takes a twentieth of the time. --- app/src/main/cpp/fakeinput_steam.cpp | 49 +++++- .../droiddeck/launcher/core/LogRedactor.kt | 113 ++++++++++---- .../com/droiddeck/launcher/input/PadMotion.kt | 29 +++- .../com/droiddeck/launcher/ui/SteamHome.kt | 145 ++++++++++++------ .../com/droiddeck/launcher/ui/StoresPage.kt | 9 +- .../overlay/usr/local/bin/droiddeck-agent | 3 + .../overlay/usr/local/bin/droiddeck-game-env | 14 ++ .../usr/local/bin/droiddeck-seed-redists | 35 +++-- .../overlay/usr/local/bin/droiddeck-session | 13 +- tools/linuxfs/preload/netif.c | 118 +++++++++++--- tools/proot/fastpath/fastpath.c | 13 ++ 11 files changed, 416 insertions(+), 125 deletions(-) diff --git a/app/src/main/cpp/fakeinput_steam.cpp b/app/src/main/cpp/fakeinput_steam.cpp index 913d11914..64b6ddec4 100644 --- a/app/src/main/cpp/fakeinput_steam.cpp +++ b/app/src/main/cpp/fakeinput_steam.cpp @@ -266,6 +266,31 @@ static std::unordered_map &ff_effects() { return *map; } +// Every fd the maps hold, readable without controller_mutex(): the hooks see each read, write, +// ioctl and poll a process makes, and almost none are on these. Set before an fd is handed out, +// cleared once no map holds it; an fd past the bitmap takes the lock once any such fd exists. +static constexpr int kWatchedFds = 1 << 16; +static constexpr int kWatchedBits = sizeof(unsigned long) * 8; +static std::atomic watched_fds[kWatchedFds / kWatchedBits]; +static std::atomic watched_beyond{false}; + +static void watch_fd(int fd) { + if (fd < 0) return; + if (fd >= kWatchedFds) watched_beyond.store(true, std::memory_order_release); + else watched_fds[fd / kWatchedBits].fetch_or(1UL << (fd % kWatchedBits), std::memory_order_release); +} + +static void unwatch_fd(int fd) { + if (fd >= 0 && fd < kWatchedFds) + watched_fds[fd / kWatchedBits].fetch_and(~(1UL << (fd % kWatchedBits)), std::memory_order_release); +} + +static bool watched(int fd) { + if (fd < 0) return false; + if (fd >= kWatchedFds) return watched_beyond.load(std::memory_order_acquire); + return (watched_fds[fd / kWatchedBits].load(std::memory_order_acquire) >> (fd % kWatchedBits)) & 1; +} + static const char *fake_hook_dir() { return config().hook_dir; } static const char *fake_udev_data_dir() { return config().udev_data_dir; } static bool fake_vibration_enabled() { return config().vibration_enabled; } @@ -692,6 +717,7 @@ open_fake_input_ring(const char *event, int flags) { { std::lock_guard guard(controller_mutex()); controller_map()[fd] = controller; + watch_fd(fd); } Logger::log("Adding ring-backed controller, fd %d event %s slot %d\n", fd, @@ -774,11 +800,13 @@ copy_slot_ioctl_string(int op, void *argp, const char *format, int event_number) } __attribute__((visibility("hidden"))) static bool is_fake_input_fd(int fd) { + if (!watched(fd)) return false; std::lock_guard guard(controller_mutex()); return controller_map().find(fd) != controller_map().end(); } __attribute__((visibility("hidden"))) static bool fake_fd_is_stale(int fd) { + if (!watched(fd)) return false; std::lock_guard guard(controller_mutex()); auto controller = controller_map().find(fd); return controller != controller_map().end() && @@ -892,6 +920,7 @@ __attribute__((visibility("hidden"))) static int open_uinput(int flags) { writer->owner = getpid(); std::lock_guard guard(controller_mutex()); uinput_map()[fd] = writer; + watch_fd(fd); Logger::log("uinput: opened as fd %d\n", fd); return fd; } @@ -1556,6 +1585,7 @@ __attribute__((visibility("hidden"))) static int open_deck_hidraw(int flags) { { std::lock_guard guard(controller_mutex()); deck_map()[pair[0]] = deck; + watch_fd(pair[0]); } pthread_t thread; auto *arg = new std::shared_ptr(deck); @@ -1563,6 +1593,7 @@ __attribute__((visibility("hidden"))) static int open_deck_hidraw(int flags) { delete arg; std::lock_guard guard(controller_mutex()); deck_map().erase(pair[0]); + unwatch_fd(pair[0]); syscall(SYS_close, pair[0]); syscall(SYS_close, pair[1]); munmap(mapping, mapping_size); @@ -1898,6 +1929,7 @@ __attribute__((visibility("hidden"))) static int open_touch_hidraw(int flags) { { std::lock_guard guard(controller_mutex()); deck_map()[pair[0]] = touch; + watch_fd(pair[0]); } touch_state([](TouchRingFile &r) { r.opened++; }); pthread_t thread; @@ -1906,6 +1938,7 @@ __attribute__((visibility("hidden"))) static int open_touch_hidraw(int flags) { delete arg; std::lock_guard guard(controller_mutex()); deck_map().erase(pair[0]); + unwatch_fd(pair[0]); syscall(SYS_close, pair[0]); syscall(SYS_close, pair[1]); touch_state([](TouchRingFile &r) { if (r.opened) r.opened--; }); @@ -2689,6 +2722,7 @@ static int fake_stat_path(const char *pathname, S *statbuf, Real real) { template static int fake_stat_fd(int fd, S *buf, Real real) { int ret = real(fd, buf); + if (ret != 0 || !watched(fd)) return ret; std::lock_guard guard(controller_mutex()); if (ret == 0 && deck_map().count(fd)) { @@ -2898,6 +2932,7 @@ EXPORT int ioctl(int fd, ioctl_request_t op, ...) { // The lock must not be held across the passthrough: binder's transport is a // blocking ioctl(BINDER_WRITE_READ), so a parked binder pool thread would own // controller_mutex() for as long as it waits and deadlock every other ioctl. + if (!watched(fd)) return syscall(SYS_ioctl, fd, op, argp); std::unique_lock guard(controller_mutex()); auto maker = uinput_map().find(fd); if (maker != uinput_map().end()) return ioctl_uinput(*maker->second, op, argp); @@ -3117,6 +3152,7 @@ EXPORT int ioctl(int fd, ioctl_request_t op, ...) { EXPORT int close(int fd) { static auto my_close = reinterpret_cast(dlsym(RTLD_NEXT, "close")); + if (!watched(fd)) return my_close(fd); close_uinput(fd); std::unique_lock guard(controller_mutex()); deck_map().erase(fd); @@ -3127,6 +3163,7 @@ EXPORT int close(int fd) { controller->second->closed = true; controller_map().erase(fd); } + unwatch_fd(fd); guard.unlock(); return my_close(fd); @@ -3135,6 +3172,7 @@ EXPORT int close(int fd) { static constexpr int kMaxRingWaitMs = 2; EXPORT ssize_t read(int fd, void *buf, size_t count) { + if (!watched(fd)) return syscall(SYS_read, fd, buf, count); std::unique_lock guard(controller_mutex()); auto controller = controller_map().find(fd); if (controller == controller_map().end()) { @@ -3233,6 +3271,7 @@ EXPORT ssize_t read(int fd, void *buf, size_t count) { EXPORT ssize_t write(int fd, const void *buf, size_t count) { static auto my_write = reinterpret_cast(dlsym(RTLD_NEXT, "write")); + if (!watched(fd)) return my_write(fd, buf, count); std::unique_lock guard(controller_mutex()); auto made = uinput_map().find(fd); if (made != uinput_map().end()) return write_uinput(*made->second, buf, count); @@ -3262,6 +3301,7 @@ EXPORT ssize_t write(int fd, const void *buf, size_t count) { } EXPORT ssize_t writev(int fd, const struct iovec *iov, int iovcnt) { + if (!watched(fd)) return syscall(SYS_writev, fd, iov, iovcnt); std::unique_lock guard(controller_mutex()); if (deck_map().count(fd)) { ssize_t total = 0; @@ -3312,11 +3352,14 @@ static int poll_fake(struct pollfd *fds, nfds_t nfds, int timeout, static auto my_poll = reinterpret_cast(dlsym(RTLD_NEXT, "poll")); static auto my_ppoll = reinterpret_cast(dlsym(RTLD_NEXT, "ppoll")); + nfds_t first = 0; + while (first < nfds && !watched(fds[first].fd)) first++; bool has_fake_fds = false; std::vector real_fds; - real_fds.reserve(nfds); - std::vector> fake_fds(nfds); - { + std::vector> fake_fds; + if (first < nfds) { + real_fds.reserve(nfds); + fake_fds.resize(nfds); std::lock_guard guard(controller_mutex()); for (nfds_t i = 0; i < nfds; i++) { real_fds.push_back(fds[i]); diff --git a/app/src/main/java/com/droiddeck/launcher/core/LogRedactor.kt b/app/src/main/java/com/droiddeck/launcher/core/LogRedactor.kt index ad48f2664..4406a7028 100644 --- a/app/src/main/java/com/droiddeck/launcher/core/LogRedactor.kt +++ b/app/src/main/java/com/droiddeck/launcher/core/LogRedactor.kt @@ -93,9 +93,12 @@ object LogRedactor { "(?i)(? = emptyList() + private var accounts: List = emptyList() /** * Learns every Steam account on the device from the client's loginusers.vdf - its AccountName @@ -103,12 +106,13 @@ object LogRedactor { * Names under three characters are skipped: blanking every "a" would ruin a log. */ fun learnAccounts(loginUsers: java.io.File) { - val found = ArrayList() + val found = ArrayList() try { if (loginUsers.isFile) { val kv = Regex("\"(AccountName|PersonaName)\"\\s+\"([^\"]*)\"") kv.findAll(loginUsers.readText()).map { it.groupValues[2].trim() }.filter { it.length >= 3 }.distinct().forEach { name -> - found += Regex("(?i)(? = emptyList() + private var own: List = emptyList() /** * Learns the device's addresses from the link file the app writes for the session @@ -133,7 +137,7 @@ object LogRedactor { * private, link-local and loopback addresses identify nobody and are left out. */ fun learnOwnAddresses(linkFile: java.io.File) { - val found = ArrayList() + val found = ArrayList() try { if (linkFile.isFile) linkFile.forEachLine { line -> val addr = line.trim().takeIf { it.startsWith("addr ") }?.split(Regex("\\s+"))?.getOrNull(1) ?: return@forEachLine @@ -142,9 +146,12 @@ object LogRedactor { val groups = expand6(addr)?.take(4) ?: return@forEachLine // Any spelling of an address in this /64: leading zeros dropped, :: anywhere after. val prefix = groups.joinToString(":") { g -> "0{0,3}" + Regex.escape(g.trimStart('0').ifEmpty { "0" }) } - found += Regex("(?i)(? found += Regex("(? found += Learned(Regex("(?$q" } + /** + * A line on its way through [redact]. Each rule runs only on a line holding what it cannot match + * without - a word, enough separators, a long enough run: most of a Steam log is lines no rule + * touches, and a session's logs went through every rule at about a megabyte a second. A line with anything but ASCII in it goes through + * every case-insensitive rule, since Android's regex folds case more widely than lowercase(). + */ + private class Line(var text: String) { + private val unfolded = text.any { it.code >= 0x80 } + private var lower: String? = null + + fun has(vararg words: String): Boolean { + if (unfolded) return true + val folded = lower ?: text.lowercase().also { lower = it } + return words.any { folded.contains(it) } + } + + fun set(next: String) { + if (next != text) { + text = next + lower = null + } + } + + fun holds(c: Char, times: Int): Boolean { + var n = 0 + for (ch in text) if (ch == c && ++n >= times) return true + return false + } + + inline fun hasRun(length: Int, inRun: (Char) -> Boolean): Boolean { + var n = 0 + for (ch in text) if (!inRun(ch)) n = 0 else if (++n >= length) return true + return false + } + } + + private fun isHex(c: Char) = c in '0'..'9' || c in 'a'..'f' || c in 'A'..'F' + /** [line] with every credential shape replaced. Null- and exception-safe by construction. */ fun redact(line: String): String { if (line.isEmpty()) return line return try { - var out = line - out = MAC_FIELD.replace(out) { "${it.groupValues[1]}" } - out = MAC.replace(out, "") - out = DEVICE_IDENTIFIER.replace(out) { + val out = Line(line) + if (out.has("mac")) out.set(MAC_FIELD.replace(out.text) { "${it.groupValues[1]}" }) + if (out.holds(':', 5) || out.holds('-', 5)) out.set(MAC.replace(out.text, "")) + if (out.has("serial", "android")) out.set(DEVICE_IDENTIFIER.replace(out.text) { val value = it.groupValues[2] val quote = value.first().takeIf { char -> char == '\"' || char == '\'' }?.toString().orEmpty() "${it.groupValues[1]}${quote}${quote}" + }) + if (out.holds('-', 4)) out.set(GUID.replace(out.text, "")) + if (out.has("jwt")) out.set(JWT_LABELLED.replace(out.text) { "${it.groupValues[1]}" }) + if ("ey" in out.text) out.set(JWT_BASE64.replace(out.text, "")) + if (out.has("token", "auth", "ticket", "sessionid", "steamloginsecure", "api", "machine", "pass", "pwd", "secret")) { + out.set(SECRET_KV.replace(out.text) { "${it.groupValues[1]}${it.groupValues[2]}" }) } - out = GUID.replace(out, "") - out = JWT_LABELLED.replace(out) { "${it.groupValues[1]}" } - out = JWT_BASE64.replace(out, "") - out = SECRET_KV.replace(out) { "${it.groupValues[1]}${it.groupValues[2]}" } - out = GUARD_CODE.replace(out) { "${it.groupValues[1]}" } - out = WEBAPI_KEY.replace(out, "") + if (out.has("guard", "factor", "2fa")) out.set(GUARD_CODE.replace(out.text) { "${it.groupValues[1]}" }) + if (out.hasRun(32, ::isHex)) out.set(WEBAPI_KEY.replace(out.text, "")) // Mask, not delete: the last four digits let a reader correlate lines to one account. - out = STEAMID64.replace(out) { "${it.groupValues[1]}********${it.groupValues[3]}" } - out = STEAMID3.replace(out) { m -> + if ("76561" in out.text) out.set(STEAMID64.replace(out.text) { "${it.groupValues[1]}********${it.groupValues[3]}" }) + if ("[U:1:" in out.text) out.set(STEAMID3.replace(out.text) { m -> val id = m.groupValues[1] "[U:1:${if (id.length > 4) "*".repeat(id.length - 4) + id.takeLast(4) else id}]" + }) + if (out.has("external")) out.set(EXTERNAL_ADDR.replace(out.text) { "${it.groupValues[1]}" }) + for (r in own) if (r.needs == null || out.has(r.needs)) out.set(r.regex.replace(out.text, "")) + if (out.has("onloginstatechange")) out.set(LOGIN_STATE.replace(out.text) { "${it.groupValues[1]}" }) + if ("OnLoginUsersChanged " in out.text) out.set(LOGIN_USERS.replace(out.text) { "${it.groupValues[1]}" }) + if (out.has("account", "user")) { + out.set(ACCOUNT_KV.replace(out.text) { "${it.groupValues[1]}${it.groupValues[2]}${quoted(it.groupValues[3])}" }) } - out = EXTERNAL_ADDR.replace(out) { "${it.groupValues[1]}" } - for (r in own) out = r.replace(out, "") - out = LOGIN_STATE.replace(out) { "${it.groupValues[1]}" } - out = LOGIN_USERS.replace(out) { "${it.groupValues[1]}" } - out = ACCOUNT_KV.replace(out) { "${it.groupValues[1]}${it.groupValues[2]}${quoted(it.groupValues[3])}" } - out = LOGIN_KV.replace(out) { "${it.groupValues[1]}${it.groupValues[2]}${quoted(it.groupValues[3])}" } - for (r in accounts) out = r.replace(out, "") - out = EMAIL.replace(out, "") - out = RESIDUAL.replace(out) { "${it.groupValues[1]}=" } - out = LONG_TOKEN.replace(out, "") - out + if (out.has("login")) out.set(LOGIN_KV.replace(out.text) { "${it.groupValues[1]}${it.groupValues[2]}${quoted(it.groupValues[3])}" }) + for (r in accounts) if (r.needs == null || out.has(r.needs)) out.set(r.regex.replace(out.text, "")) + if ('@' in out.text) out.set(EMAIL.replace(out.text, "")) + if (out.has("jwt", "token", "ticket", "sessionid", "steamloginsecure", "machineauth")) { + out.set(RESIDUAL.replace(out.text) { "${it.groupValues[1]}=" }) + } + if (out.hasRun(88) { it in 'a'..'z' || it in 'A'..'Z' || it in '0'..'9' || it == '_' || it == '-' }) { + out.set(LONG_TOKEN.replace(out.text, "")) + } + out.text } catch (t: Throwable) { // A log line is never worth crashing a session over, but an unscrubbed one must not // reach the file either. diff --git a/app/src/main/java/com/droiddeck/launcher/input/PadMotion.kt b/app/src/main/java/com/droiddeck/launcher/input/PadMotion.kt index 0d26272b8..7058bf300 100644 --- a/app/src/main/java/com/droiddeck/launcher/input/PadMotion.kt +++ b/app/src/main/java/com/droiddeck/launcher/input/PadMotion.kt @@ -35,6 +35,9 @@ class PadMotion(private val context: Context, private val rotation: () -> Int) : private val gyro = ShortArray(3) private var reading = false private var idlePolls = 0 + // Asking the display costs more than the rest of a reading, which arrives every 2 ms. + private var turn = Surface.ROTATION_0 + private var turnAt = 0L fun start() { if (thread != null || sensors == null) return @@ -86,6 +89,7 @@ class PadMotion(private val context: Context, private val rotation: () -> Int) : idlePolls = if (wanted) 0 else idlePolls + 1 if (wanted && !reading) { reading = true + turnAt = 0L gyroscope?.let { sensors?.registerListener(this, it, SAMPLING_US, handler) } accelerometer?.let { sensors?.registerListener(this, it, SAMPLING_US, handler) } Log.i(TAG, "pad motion: reading") @@ -107,17 +111,25 @@ class PadMotion(private val context: Context, private val rotation: () -> Int) : override fun onSensorChanged(event: SensorEvent) { if (!active) return val values = event.values + if (event.timestamp - turnAt > ROTATION_REFRESH_NS) { + turn = rotation() + turnAt = event.timestamp + } // Natural orientation to the screen's: Android's display-rotation transform. - val (x, y) = when (rotation()) { - Surface.ROTATION_90 -> -values[1] to values[0] - Surface.ROTATION_180 -> -values[0] to -values[1] - Surface.ROTATION_270 -> values[1] to -values[0] - else -> values[0] to values[1] + val x: Float + val y: Float + when (turn) { + Surface.ROTATION_90 -> { x = -values[1]; y = values[0] } + Surface.ROTATION_180 -> { x = -values[0]; y = -values[1] } + Surface.ROTATION_270 -> { x = values[1]; y = -values[0] } + else -> { x = values[0]; y = values[1] } } val z = values[2] - val (target, scale) = when (event.sensor.type) { - Sensor.TYPE_GYROSCOPE -> gyro to GYRO_COUNTS_PER_RAD_S - Sensor.TYPE_ACCELEROMETER -> accel to ACCEL_COUNTS_PER_M_S2 + val target: ShortArray + val scale: Float + when (event.sensor.type) { + Sensor.TYPE_GYROSCOPE -> { target = gyro; scale = GYRO_COUNTS_PER_RAD_S } + Sensor.TYPE_ACCELEROMETER -> { target = accel; scale = ACCEL_COUNTS_PER_M_S2 } else -> return } // Screen frame (right, up, towards the player) to the Deck's (right, away, up). @@ -140,6 +152,7 @@ class PadMotion(private val context: Context, private val rotation: () -> Int) : private const val SAMPLING_US = 4000 /** How often [follow] checks whether the client wants motion. */ private const val POLL_MS = 500L + private const val ROTATION_REFRESH_NS = 250_000_000L private const val ACCEL_COUNTS_PER_M_S2 = 16384f / SensorManager.GRAVITY_EARTH private const val GYRO_COUNTS_PER_RAD_S = (32768f / 2000f) * (180f / Math.PI.toFloat()) } diff --git a/app/src/main/java/com/droiddeck/launcher/ui/SteamHome.kt b/app/src/main/java/com/droiddeck/launcher/ui/SteamHome.kt index db261e51a..c5e1a1cb7 100644 --- a/app/src/main/java/com/droiddeck/launcher/ui/SteamHome.kt +++ b/app/src/main/java/com/droiddeck/launcher/ui/SteamHome.kt @@ -4,7 +4,6 @@ import androidx.compose.ui.platform.testTag import com.droiddeck.launcher.R import androidx.compose.ui.res.stringResource import androidx.compose.animation.core.FastOutSlowInEasing -import androidx.compose.animation.core.LinearEasing import androidx.compose.animation.core.RepeatMode import androidx.compose.runtime.State import androidx.compose.animation.core.animateFloat @@ -12,7 +11,6 @@ import androidx.compose.animation.core.infiniteRepeatable import androidx.compose.animation.core.rememberInfiniteTransition import androidx.compose.animation.core.tween import androidx.compose.foundation.background -import androidx.compose.foundation.border import androidx.compose.foundation.layout.Arrangement import androidx.compose.foundation.layout.Box import androidx.compose.foundation.layout.BoxWithConstraints @@ -41,21 +39,38 @@ import androidx.compose.ui.layout.boundsInParent import androidx.compose.ui.layout.onPlaced import androidx.compose.ui.Alignment import androidx.compose.ui.Modifier -import androidx.compose.ui.draw.clip import androidx.compose.ui.draw.clipToBounds import androidx.compose.ui.draw.drawBehind import androidx.compose.ui.geometry.Offset import androidx.compose.ui.graphics.Brush import androidx.compose.ui.graphics.Color import androidx.compose.ui.graphics.graphicsLayer -import androidx.compose.ui.layout.ContentScale import androidx.compose.ui.unit.dp -import coil.compose.AsyncImage import com.droiddeck.launcher.frontend.Library +import androidx.compose.foundation.layout.width +import androidx.compose.runtime.LaunchedEffect +import androidx.compose.runtime.key +import androidx.compose.runtime.mutableFloatStateOf +import androidx.compose.runtime.withFrameNanos +import androidx.compose.ui.geometry.CornerRadius +import androidx.compose.ui.geometry.Size +import androidx.compose.ui.graphics.drawscope.DrawScope +import androidx.compose.ui.graphics.drawscope.Stroke +import androidx.compose.ui.graphics.drawscope.inset +import androidx.compose.ui.graphics.painter.Painter +import androidx.compose.ui.platform.LocalContext +import androidx.compose.ui.platform.LocalDensity +import coil.compose.rememberAsyncImagePainter +import coil.request.ImageRequest +import coil.size.Scale +import coil.transform.RoundedCornersTransformation +import kotlin.math.roundToInt /** From this many games the Steam tab is a wall; fewer would only repeat the same covers. */ private const val WALL_MIN_GAMES = 4 +private const val DRIFT_STEP_NS = 15_000_000L + /** * The Steam tab: the library as a slowly drifting, tilted wall of capsules (a few games instead * lean on their own; none, the DroidDeck mark wandering a blank wall), and over it the wordmark and the one thing to do here - @@ -126,32 +141,49 @@ internal fun CapsuleWall( games: List, driftMs: Int = if (games.isEmpty()) 75_000 else 40_000, modifier: Modifier = Modifier, -) = TiltedWall(games.size, driftMs, modifier) { i, m -> - Capsule(if (games.isEmpty()) null else games[i], RoundedCornerShape(10.dp), m) +) { + val pal = LocalPalette.current + val blank = remember(pal) { WallCapsule(Brush.linearGradient(listOf(pal.surface, pal.background)), edge = pal.line) } + TiltedWall(games.size, driftMs, modifier) { i -> if (games.isEmpty()) blank else WallCapsule(artBrush(hueOf(games[i].name)), games[i].art) } } +/** One capsule of a [TiltedWall]: its ground, the art laid over it once loaded, and an outline. */ +internal class WallCapsule(val ground: Brush, val art: Any? = null, val edge: Color? = null) + /** - * [CapsuleWall]'s tilted, drifting columns for any [count] of capsules; [capsule] draws number i - * (0 until [count], or 0 for each blank one when [count] is 0) at the modifier it is given. + * [CapsuleWall]'s tilted, drifting columns for any [count] of capsules; [capsule] describes number i + * (0 until [count], or 0 for each blank one when [count] is 0). Each column is one drawing with the + * covers' corners cut into their bitmaps: a rounded clip under the tilt is rasterised on the CPU, + * for every capsule on every frame. */ @Composable internal fun TiltedWall( count: Int, driftMs: Int, modifier: Modifier = Modifier, - capsule: @Composable (index: Int, modifier: Modifier) -> Unit, + capsule: (index: Int) -> WallCapsule, ) { val capW = 112.dp val capH = 168.dp val gap = 14.dp - val transition = rememberInfiniteTransition(label = "wall") - val drift = transition.animateFloat( - 0f, 1f, - infiniteRepeatable(tween(driftMs, easing = LinearEasing)), - label = "drift", - ) // Animations off in the system settings: a still wall. val still = Motion.scale == 0f + // The wall moves a few pixels a step. Stepped on frames at most every 15 ms it looks the same as + // stepped on every frame, which on a 120 Hz screen drew it twice as often. + val drift = remember { mutableFloatStateOf(0f) } + if (!still) LaunchedEffect(driftMs) { + val period = driftMs * 1_000_000.0 * Motion.scale + var start = 0L + var shown = 0L + while (true) withFrameNanos { now -> + if (start == 0L) start = now + if (shown == 0L || now - shown >= DRIFT_STEP_NS) { + shown = now + drift.floatValue = ((now - start) % period / period).toFloat() + } + } + } + val density = LocalDensity.current BoxWithConstraints(modifier.fillMaxSize()) { // Centred on the page and big enough that, once tilted, it still covers every corner. val tilt = Math.toRadians(13.0) @@ -162,6 +194,17 @@ internal fun TiltedWall( val columns = ((wallW + gap) / (capW + gap)).toInt() + 1 val perRun = ((wallH + gap) / (capH + gap)).toInt() + 1 val run = (capH + gap) * perRun + val cap = with(density) { Size(capW.toPx(), capH.toPx()) } + val step = with(density) { (capH + gap).toPx() } + val radius = with(density) { 10.dp.toPx() } + val line = with(density) { 1.dp.toPx() } + val indexOf = { c: Int, i: Int -> if (count == 0) 0 else (c * 5 + (i % perRun) * 3) % count } + val shown = remember(count, columns, perRun) { (0 until columns).flatMap { c -> (0 until perRun).map { indexOf(c, it) } }.distinct() } + val looks = HashMap>(shown.size * 2) + for (index in shown) key(index) { + val look = capsule(index) + looks[index] = look to look.art?.let { rememberCapsuleArt(it, cap, radius) } + } Row( horizontalArrangement = Arrangement.spacedBy(gap), modifier = Modifier @@ -171,26 +214,52 @@ internal fun TiltedWall( .graphicsLayer { rotationZ = -13f }, ) { repeat(columns) { c -> - Column( - verticalArrangement = Arrangement.spacedBy(gap), - modifier = Modifier.wrapContentHeight(Alignment.Top, unbounded = true).graphicsLayer { - val shift = if (still) 0f else run.toPx() * drift.value - translationY = if (c % 2 == 0) -shift else shift - run.toPx() - }, - ) { - repeat(perRun * 2) { i -> - capsule(if (count == 0) 0 else (c * 5 + (i % perRun) * 3) % count, Modifier.size(capW, capH)) - } - } + Spacer( + Modifier.width(capW).wrapContentHeight(Alignment.Top, unbounded = true).height(run * 2 - gap) + .graphicsLayer { + val shift = if (still) 0f else run.toPx() * drift.floatValue + translationY = if (c % 2 == 0) -shift else shift - run.toPx() + } + .drawBehind { + for (i in 0 until perRun * 2) { + val (look, art) = looks[indexOf(c, i)] ?: continue + val top = i * step + inset(0f, top, 0f, size.height - top - cap.height) { drawCapsule(look, art, radius, line) } + } + }, + ) } } } } +/** A cover sized for a capsule, its corners already cut, so it draws without a clip. */ +@Composable +private fun rememberCapsuleArt(model: Any, size: Size, radius: Float): Painter { + val context = LocalContext.current + val w = size.width.roundToInt() + val h = size.height.roundToInt() + return rememberAsyncImagePainter( + remember(model, w, h, radius) { + ImageRequest.Builder(context).data(model).size(w, h).scale(Scale.FILL) + .transformations(RoundedCornersTransformation(radius)).build() + }, + ) +} + +private fun DrawScope.drawCapsule(look: WallCapsule, art: Painter?, radius: Float, line: Float) { + drawRoundRect(look.ground, size = size, cornerRadius = CornerRadius(radius)) + if (art != null) with(art) { draw(size) } + look.edge?.let { + drawRoundRect(it, Offset(line / 2, line / 2), Size(size.width - line, size.height - line), CornerRadius(radius - line / 2), style = Stroke(line)) + } +} + /** One to three games, each a large capsule leaning on the others and floating a little. */ @Composable private fun CapsuleFan(games: List) { val pal = LocalPalette.current + val density = LocalDensity.current val transition = rememberInfiniteTransition(label = "fan") val floats = listOf(9_000, 11_000, 13_000).map { ms -> transition.animateFloat(0f, 1f, infiniteRepeatable(tween(ms, easing = FastOutSlowInEasing), RepeatMode.Reverse), label = "float") @@ -212,12 +281,14 @@ private fun CapsuleFan(games: List) { ) }, ) { + val radius = with(density) { 14.dp.toPx() } for (i in games.indices.reversed()) { val slot = slots[i] val h = maxHeight * slot.height val v: State = floats[i] - Capsule( - games[i], RoundedCornerShape(14.dp), + val look = WallCapsule(artBrush(hueOf(games[i].name)), games[i].art) + val art = look.art?.let { rememberCapsuleArt(it, with(density) { Size((h * 2f / 3f).toPx(), h.toPx()) }, radius) } + Spacer( Modifier .offset(x = maxWidth * slot.x, y = maxHeight * slot.y) .size(h * 2f / 3f, h) @@ -228,23 +299,11 @@ private fun CapsuleFan(games: List) { shadowElevation = 24.dp.toPx() shape = RoundedCornerShape(14.dp) clip = false - }, + } + .drawBehind { drawCapsule(look, art, radius, 0f) }, ) } } } private class FanSlot(val x: Float, val y: Float, val height: Float, val lean: Float) - -/** A game's portrait capsule, or a blank one standing in for a game yet to be installed. */ -@Composable -private fun Capsule(g: Library.SteamGame?, shape: RoundedCornerShape, modifier: Modifier) { - val pal = LocalPalette.current - if (g == null) { - Box(modifier.clip(shape).background(Brush.linearGradient(listOf(pal.surface, pal.background))).border(1.dp, pal.line, shape)) - return - } - Box(modifier.clip(shape).background(artBrush(hueOf(g.name)))) { - if (g.art != null) AsyncImage(model = g.art, contentDescription = null, contentScale = ContentScale.Crop, modifier = Modifier.matchParentSize()) - } -} diff --git a/app/src/main/java/com/droiddeck/launcher/ui/StoresPage.kt b/app/src/main/java/com/droiddeck/launcher/ui/StoresPage.kt index ec3516dbe..a23c9ebaf 100644 --- a/app/src/main/java/com/droiddeck/launcher/ui/StoresPage.kt +++ b/app/src/main/java/com/droiddeck/launcher/ui/StoresPage.kt @@ -36,6 +36,7 @@ import androidx.compose.ui.layout.onSizeChanged import androidx.compose.ui.draw.drawWithContent import androidx.compose.ui.draw.drawBehind import androidx.compose.ui.graphics.Brush +import androidx.compose.ui.graphics.SolidColor import androidx.compose.ui.draw.clipToBounds import androidx.compose.ui.draw.blur import androidx.compose.foundation.layout.wrapContentHeight @@ -774,14 +775,12 @@ private fun SignInCard(store: Store, height: Dp) { .takeIf { it.size >= 8 }.orEmpty() } val shape = RoundedCornerShape(20.dp) - val capsule = RoundedCornerShape(10.dp) + val blank = WallCapsule(Brush.linearGradient(listOf(c.fill, colors.background)), edge = c.dot.copy(alpha = 0.22f)) + val ground = SolidColor(c.fill) Box(Modifier.fillMaxWidth().height(height.coerceAtLeast(320.dp)).clip(shape).background(colors.background).border(1.dp, pal.line, shape)) { // The storefront arrives a moment after the page: its wall fades in over the blank one. androidx.compose.animation.Crossfade(art, animationSpec = Motion.tw(600), label = "signInWall") { tiles -> - TiltedWall(tiles.size, if (tiles.isEmpty()) 75_000 else 50_000) { i, m -> - if (tiles.isEmpty()) Box(m.clip(capsule).background(Brush.linearGradient(listOf(c.fill, colors.background))).border(1.dp, c.dot.copy(alpha = 0.22f), capsule)) - else Box(m.clip(capsule).background(c.fill)) { AsyncImage(model = tiles[i], contentDescription = null, contentScale = ContentScale.Crop, modifier = Modifier.matchParentSize()) } - } + TiltedWall(tiles.size, if (tiles.isEmpty()) 75_000 else 50_000) { i -> if (tiles.isEmpty()) blank else WallCapsule(ground, tiles[i]) } } // The wall gives way to the words: dark at the left and the foot, and the store's glow under them. Box( diff --git a/tools/linuxfs/overlay/usr/local/bin/droiddeck-agent b/tools/linuxfs/overlay/usr/local/bin/droiddeck-agent index 972c1502b..0df6d5363 100755 --- a/tools/linuxfs/overlay/usr/local/bin/droiddeck-agent +++ b/tools/linuxfs/overlay/usr/local/bin/droiddeck-agent @@ -287,6 +287,9 @@ class FocusWatcher(threading.Thread): x = X(os.environ["DISPLAY"]) wanted = {x.atom(name) for name in FOCUS_PROPS} x.select(x.root, 0x400000) # PropertyChangeMask + # Waits for events as long as there are none: the connect timeout left in place + # here dropped and remade the connection, and took a snapshot, every few seconds. + x.s.settimeout(None) self.changed.set() while True: event = x.next_event() diff --git a/tools/linuxfs/overlay/usr/local/bin/droiddeck-game-env b/tools/linuxfs/overlay/usr/local/bin/droiddeck-game-env index e8f5605a4..067212e34 100755 --- a/tools/linuxfs/overlay/usr/local/bin/droiddeck-game-env +++ b/tools/linuxfs/overlay/usr/local/bin/droiddeck-game-env @@ -106,6 +106,19 @@ def godot_sentry(game): return {"WINEDLLOVERRIDES": ";".join(n + "=d" for n in sentry)}, [], "Godot: Sentry crash handler off" +def skip_red_launcher(command): + """Cyberpunk 2077's prelauncher opens REDlauncher, a Qt WebEngine window that hands over to the + game half a minute later and then stays up beside it, well over a core busy for as long as the + game runs. The game is started itself instead; the prelauncher's own --launcher-skip started it + twice.""" + if len(command) > 2 and os.path.basename(command[2]).lower() == "redprelauncher.exe": + game = os.path.join(os.path.dirname(command[2]), "bin", "x64", "Cyberpunk2077.exe") + if os.path.isfile(game): + print("droiddeck-game-env: REDlauncher skipped", file=sys.stderr) + return command[:2] + [game] + command[3:] + return command + + def engine_fixes(exe, args): """Environment and extra arguments a game needs because of what it is built with.""" game = Game(exe, args) @@ -269,6 +282,7 @@ def main(): waiting = len(command) > 1 and command[1] == "waitforexitandrun" fixes = {} if waiting: + command = skip_red_launcher(command) fixes, extra, notes = engine_fixes(command[2], command[3:]) if len(command) > 2 else ({}, [], []) for note in notes: print("droiddeck-game-env: " + note, file=sys.stderr) diff --git a/tools/linuxfs/overlay/usr/local/bin/droiddeck-seed-redists b/tools/linuxfs/overlay/usr/local/bin/droiddeck-seed-redists index 467a35987..7b430422a 100755 --- a/tools/linuxfs/overlay/usr/local/bin/droiddeck-seed-redists +++ b/tools/linuxfs/overlay/usr/local/bin/droiddeck-seed-redists @@ -108,12 +108,18 @@ vcrt() { done } -# The stamp is the set of names, taken before the block below dates its keys: stamped from the -# dated block it never matched, and every prefix had the whole block appended again on every beat. -stamp=$(printf '%s vcrt %s.%s.%s' "$pairs" "$VCRT_MAJOR" "$VCRT_MINOR" "$VCRT_BUILD" | cksum) +# Each prefix's marker lists the names it was given, so it is handed only what it lacks. One stamp +# for the whole set flipped between the session's set and the evaluator's (which adds the game's +# own names) on every launch, and every prefix was appended to again, inside the launch. +want=() +declare -A wanted=() +while IFS= read -r line; do + [[ $line == *$'\t'* ]] && [ -z "${wanted[$line]:-}" ] && wanted[$line]=1 && want+=("$line") +done <<<"$pairs" +want+=("vcrt"$'\t'"$VCRT_MAJOR.$VCRT_MINOR.$VCRT_BUILD") printf -v now '%(%s)T' -1 -block=$(printf '%s\n' "$pairs" | awk -F'\t' -v now="$now" ' +block_for() { printf '%s\n' "$@" | awk -F'\t' -v now="$now" ' { path = $1 sub(/^HKEY_LOCAL_MACHINE\\\\/, "", path) @@ -127,9 +133,10 @@ block=$(printf '%s\n' "$pairs" | awk -F'\t' -v now="$now" ' next printf "\n[%s] %d\n\"%s\"=dword:00000001\n", "Software\\\\Wow6432Node\\\\" substr(path, 11), now, $2 } -') -block="$block -$(vcrt "$now")" +' + local line + for line; do [[ $line == vcrt$'\t'* ]] && vcrt "$now"; done +} # Proton builds a new prefix from its template, and the client runs the install scripts in that # prefix moments later, so the template carries the markers too. Its date is kept: Proton reads a @@ -147,13 +154,17 @@ for reg in "$steam_root"/steamapps/common/Proton*/files/share/default_pfx*/syste if [ -f "$legacy" ] && [ ! -f "$seeded" ]; then mv -f "$legacy" "$seeded" fi - have= - [ -f "$seeded" ] && read -r have < "$seeded" - [ "$have" = "$stamp" ] && continue + declare -A had=() + if [ -f "$seeded" ]; then + while IFS= read -r line; do [[ $line == *$'\t'* ]] && had[$line]=1; done <"$seeded" + fi + missing=() + for line in "${want[@]}"; do [ -n "${had[$line]:-}" ] || missing+=("$line"); done + [ ${#missing[@]} -eq 0 ] && continue dated=$(mktemp) || continue touch -r "$reg" "$dated" - if printf '%s\n' "$block" >>"$reg"; then - printf '%s\n' "$stamp" >"$seeded" + if printf '%s\n' "$(block_for "${missing[@]}")" >>"$reg"; then + printf '%s\n' "${!had[@]}" "${missing[@]}" >"$seeded" echo "== seeded redist markers into $reg" fi touch -r "$dated" "$reg" diff --git a/tools/linuxfs/overlay/usr/local/bin/droiddeck-session b/tools/linuxfs/overlay/usr/local/bin/droiddeck-session index 4d5f0c04d..d8cd26482 100755 --- a/tools/linuxfs/overlay/usr/local/bin/droiddeck-session +++ b/tools/linuxfs/overlay/usr/local/bin/droiddeck-session @@ -642,11 +642,18 @@ case $mode in beat=$((beat + 1)) [ "$((beat % 3))" -eq 0 ] || continue libraries=("$steam_root/steamapps" /mnt/droiddeck/steamapps /mnt/droiddeck-sd/steamapps /root/Games/*/steamapps) - if seed_due; then + seed=; compat= + seed_due && seed=1 + compat_due && compat=1 + [ -n "$seed$compat" ] || continue + # Not beside a running game: the client rewrites its manifest at each launch, which made both + # due while it loaded. Its own launch seeds its prefix (droiddeck-game-env) regardless. + pgrep -x wineserver >/dev/null 2>&1 && continue + if [ -n "$seed" ]; then : > "$seed_stamp" droiddeck-seed-redists "$steam_root" >/dev/null 2>&1 || true fi - if compat_due; then + if [ -n "$compat" ]; then : > "$compat_stamp" steam-compatibility "$steam_root" >/dev/null 2>&1 || true fi @@ -869,6 +876,8 @@ BUSCONF for ((_i = 0; _i < 60; _i++)); do nap 30 [ -e "$owned" ] && exit 0 + # Loading steamclient.so under proot takes seconds of CPU: not while a game loads or runs. + pgrep -x wineserver >/dev/null 2>&1 && continue answer=$(droiddeck-steam-games probe "$steam_root" 993090 2>/dev/null) || continue case $answer in *'"993090": true'*) mkdir -p "${owned%/*}" && : > "$owned" && echo "== Lossless Scaling: owned" ;; diff --git a/tools/linuxfs/preload/netif.c b/tools/linuxfs/preload/netif.c index a7b91a5bb..0e394a7e7 100644 --- a/tools/linuxfs/preload/netif.c +++ b/tools/linuxfs/preload/netif.c @@ -21,6 +21,7 @@ #include #include #include +#include #include #include #include @@ -28,6 +29,7 @@ #include #include #include +#include #include #define LINK_FILE "/etc/droiddeck-net" @@ -35,6 +37,7 @@ #define LO_INDEX 1 #define LO_MTU 65536 #define MAX_ADDRS 16 +#define FRESH_NS 1000000000LL struct link_addr { int family; @@ -61,10 +64,11 @@ static int parse_addr(const char *text, struct link_addr *out) { return 1; } -/* Read on every call: the app rewrites the file when the device changes network. */ -static int load_link(struct link *link) { - typedef FILE *(*fopen_fn)(const char *, const char *); - fopen_fn real_fopen = (fopen_fn) dlsym(RTLD_NEXT, "fopen"); +typedef FILE *(*fopen_fn)(const char *, const char *); + +static int read_link(struct link *link) { + static fopen_fn real_fopen; + if (real_fopen == NULL) real_fopen = (fopen_fn) dlsym(RTLD_NEXT, "fopen"); FILE *f = real_fopen ? real_fopen(LINK_FILE, "re") : NULL; if (f == NULL) return 0; @@ -93,6 +97,50 @@ static int load_link(struct link *link) { return link->name[0] != '\0' && link->index > LO_INDEX && link->addr_count > 0; } +static long long now_ns(void) { + struct timespec ts; + clock_gettime(CLOCK_MONOTONIC_COARSE, &ts); + return ts.tv_sec * 1000000000LL + ts.tv_nsec; +} + +static int fresh(long long *at) { + long long then = __atomic_load_n(at, __ATOMIC_RELAXED); + return then != 0 && now_ns() - then < FRESH_NS; +} + +/* Wine's network driver reads the link several times for each table it builds, and some games + * have it build them all hundreds of times a second. The app rewrites the file when the device + * changes network, so a reading stands for a second. */ +static pthread_mutex_t link_lock = PTHREAD_MUTEX_INITIALIZER; +static struct link link_read; +static int link_ok; +static long long link_at; + +static int load_link(struct link *link) { + pthread_mutex_lock(&link_lock); + if (!fresh(&link_at)) { + link_ok = read_link(&link_read); + __atomic_store_n(&link_at, now_ns(), __ATOMIC_RELAXED); + } + int ok = link_ok; + if (ok) *link = link_read; + pthread_mutex_unlock(&link_lock); + return ok; +} + +/* See drm.c: a fork must not leave the lock held by a thread the child does not have. */ +static void link_lock_before_fork(void) { pthread_mutex_lock(&link_lock); } +static void link_unlock_after_fork(void) { pthread_mutex_unlock(&link_lock); } +static void link_reset_after_fork(void) { pthread_mutex_init(&link_lock, NULL); } + +__attribute__((constructor)) static void install_link_fork_handlers(void) { + pthread_atfork(link_lock_before_fork, link_unlock_after_fork, link_reset_after_fork); +} + +/* When the kernel's own list was of no use, it is not asked again for a second: each asking binds + * a netlink socket, a stop in the tracer, only to be refused again. */ +static long long ifaddrs_unusable_at, nameindex_unusable_at; + static void prefix_mask(int family, unsigned prefix, unsigned char *out) { int len = family == AF_INET ? 4 : 16; for (int i = 0; i < len; i++, prefix -= prefix < 8 ? prefix : 8) { @@ -168,25 +216,35 @@ static int real_list_usable(const struct ifaddrs *list) { return 0; } +typedef void (*freeifaddrs_fn)(struct ifaddrs *); +static freeifaddrs_fn real_freeifaddrs; + int getifaddrs(struct ifaddrs **out) { typedef int (*getifaddrs_fn)(struct ifaddrs **); - typedef void (*freeifaddrs_fn)(struct ifaddrs *); - getifaddrs_fn real = (getifaddrs_fn) dlsym(RTLD_NEXT, "getifaddrs"); + static getifaddrs_fn real; + if (real == NULL) real = (getifaddrs_fn) dlsym(RTLD_NEXT, "getifaddrs"); + if (real_freeifaddrs == NULL) real_freeifaddrs = (freeifaddrs_fn) dlsym(RTLD_NEXT, "freeifaddrs"); struct ifaddrs *list = NULL; - int rc = real(&list); - int saved = errno; - if (rc == 0 && real_list_usable(list)) { - *out = list; - return 0; + int asked = !fresh(&ifaddrs_unusable_at); + int rc = -1, saved = errno; + if (asked) { + rc = real(&list); + saved = errno; + if (rc == 0 && real_list_usable(list)) { + *out = list; + return 0; + } } struct link link; if (!load_link(&link)) { + if (!asked) return real(out); if (rc == 0) *out = list; errno = saved; return rc; } - if (rc == 0 && list) ((freeifaddrs_fn) dlsym(RTLD_NEXT, "freeifaddrs"))(list); + if (asked) __atomic_store_n(&ifaddrs_unusable_at, now_ns(), __ATOMIC_RELAXED); + if (rc == 0 && list) real_freeifaddrs(list); /* A leading slot keeps fill_entry()'s back link in bounds; the list starts after it. */ struct entry *block = calloc((size_t) link.addr_count + 5, sizeof(*block)); @@ -210,13 +268,13 @@ int getifaddrs(struct ifaddrs **out) { } void freeifaddrs(struct ifaddrs *list) { - typedef void (*freeifaddrs_fn)(struct ifaddrs *); if (list == NULL) return; if (list->ifa_data == list) { free((struct entry *) list - 1); return; } - ((freeifaddrs_fn) dlsym(RTLD_NEXT, "freeifaddrs"))(list); + if (real_freeifaddrs == NULL) real_freeifaddrs = (freeifaddrs_fn) dlsym(RTLD_NEXT, "freeifaddrs"); + real_freeifaddrs(list); } /* Names live in the same allocation as the array, right behind it; glibc strdup()s each one. */ @@ -227,16 +285,29 @@ struct name_block { struct if_nameindex *if_nameindex(void) { typedef struct if_nameindex *(*if_nameindex_fn)(void); - struct if_nameindex *list = ((if_nameindex_fn) dlsym(RTLD_NEXT, "if_nameindex"))(); + static if_nameindex_fn real; + if (real == NULL) real = (if_nameindex_fn) dlsym(RTLD_NEXT, "if_nameindex"); + struct if_nameindex *list = NULL; + int asked = !fresh(&nameindex_unusable_at); int saved = errno; - if (list && list[0].if_index != 0) return list; + if (asked) { + list = real(); + saved = errno; + if (list && list[0].if_index != 0) return list; + } struct link link; struct name_block *block; - if (!load_link(&link) || (block = calloc(1, sizeof(*block))) == NULL) { + if (!load_link(&link)) { + if (!asked) return real(); errno = saved; return list; } + if (asked) __atomic_store_n(&nameindex_unusable_at, now_ns(), __ATOMIC_RELAXED); + if ((block = calloc(1, sizeof(*block))) == NULL) { + if (asked) errno = saved; + return list; + } if (list) if_freenameindex(list); snprintf(block->names[0], IFNAMSIZ, "%s", LO_NAME); snprintf(block->names[1], IFNAMSIZ, "%s", link.name); @@ -489,8 +560,7 @@ static FILE *synthesize(const char *table) { /* tracer.c */ int bl_status_without_tracer(const char *path, int flags) __attribute__((visibility("hidden"))); -static FILE *open_stream(const char *symbol, const char *path, const char *mode) { - typedef FILE *(*fopen_fn)(const char *, const char *); +static FILE *open_stream(fopen_fn real, const char *path, const char *mode) { int status = mode && mode[0] == 'r' && !strchr(mode, '+') ? bl_status_without_tracer(path, O_RDONLY | O_CLOEXEC) : -1; if (status >= 0) { @@ -498,7 +568,7 @@ static FILE *open_stream(const char *symbol, const char *path, const char *mode) if (copy == NULL) close(status); return copy; } - FILE *f = ((fopen_fn) dlsym(RTLD_NEXT, symbol))(path, mode); + FILE *f = real(path, mode); if (f || path == NULL || mode == NULL || mode[0] != 'r') return f; int saved = errno; const char *table = denied_table(path); @@ -508,9 +578,13 @@ static FILE *open_stream(const char *symbol, const char *path, const char *mode) } FILE *fopen(const char *path, const char *mode) { - return open_stream("fopen", path, mode); + static fopen_fn real; + if (real == NULL) real = (fopen_fn) dlsym(RTLD_NEXT, "fopen"); + return open_stream(real, path, mode); } FILE *fopen64(const char *path, const char *mode) { - return open_stream("fopen64", path, mode); + static fopen_fn real; + if (real == NULL) real = (fopen_fn) dlsym(RTLD_NEXT, "fopen64"); + return open_stream(real, path, mode); } diff --git a/tools/proot/fastpath/fastpath.c b/tools/proot/fastpath/fastpath.c index a49703192..3914423a0 100644 --- a/tools/proot/fastpath/fastpath.c +++ b/tools/proot/fastpath/fastpath.c @@ -1651,6 +1651,19 @@ int isatty(int fd) { return r == 0; } +/* proot reads a memfd's name only to refuse the few that are then executed or locked; the rest are + * made here. The session's /proc/net and status copies, wineserver and Xwayland make them often. + * Without memfd in the kernel, proot's ashmem stands in. */ +int memfd_create(const char *name, unsigned flags) { + REAL(memfd_create, int (*)(const char *, unsigned)); + if (!name || !strncmp(name, "JITCode:", 8) || !strcmp(name, "opcache_lock") || !strncmp(name, "lib/apk/exec/", 13) + || !fp_ready()) return real_memfd_create(name, flags); + long r = sc(SYS_memfd_create, (long)name, flags, 0, 0, 0); + if (r == -ENOSYS) return real_memfd_create(name, flags); + hits++; + return ret(r); +} + /* ---------------------------------------------------------------- passwd */ /* From d9cd0d2cc8f9d89eaa656f60c08c34dac9c2ecde Mon Sep 17 00:00:00 2001 From: MaxsTechReview Date: Sat, 10 Oct 2026 19:12:20 -0400 Subject: [PATCH 2/9] Desktop: run programs, scripts and AppImages; Switch to Desktop without Deck mode (#549) * Run programs, scripts and AppImages from the desktop Windows programs open with the Proton Steam has chosen, and a Steam game's own launch program is handed to Steam. x86-64 Linux programs and game scripts run under FEX, and an exec the kernel refuses goes to droiddeck-open through libblsession's binfmt.c. Programs on noexec shared storage pass KIO's checks; a folder of Linux programs there, and sharun AppImages, are added by the app once and run from the copy. Executable scripts run without KIO's prompt, mpv plays on the software desktop, FEXServer's socket moves under XDG_RUNTIME_DIR, and Proton runtimes no longer show up as games. * Switch to Desktop from Big Picture without Deck mode Big Picture's Switch to Desktop asks the client's SteamOS manager, which the client only has when started as SteamOS (Deck mode). Without it the request failed and the screen stayed on "Switching to Desktop..." for good. The live compat helper now sees the request on its way to the client and hands it to steamos-session-select, which opens the KDE desktop as Deck mode already did. * Run x86 programs from shared storage where they lie FEX asks for the guest's PROT_EXEC when it maps a program or library, which the kernel refuses on noexec shared storage; FEX never runs those pages itself, so libblsession maps them without it in FEX's processes. An x86 game, its libraries and its start script now run in place instead of being copied in; only native code on noexec storage is still copied. A Steam library's games are never copied, and a Linux game's launch program opened from the desktop goes to Steam like a Windows one. --- .../launcher/runtime/AppImageManager.kt | 14 + .../droiddeck/launcher/runtime/UserApps.kt | 23 +- .../launcher/session/SessionFiles.kt | 4 + .../launcher/session/SessionService.kt | 55 +- tools/linuxfs/desktop/droiddeck-desktop | 9 + .../usr/local/bin/droiddeck-desktop-games | 9 +- .../overlay/usr/local/bin/droiddeck-fex | 14 +- .../overlay/usr/local/bin/droiddeck-open | 434 +++++++++++++++ .../usr/local/bin/droiddeck-proton-run | 331 +++++++++++ .../usr/local/bin/droiddeck-script-run | 5 +- .../usr/local/bin/droiddeck-steam-compat | 66 ++- .../overlay/usr/local/bin/steam-compatibility | 16 + tools/linuxfs/preload/binfmt.c | 206 +++++++ tools/linuxfs/preload/fsync.c | 3 + tools/linuxfs/preload/net.c | 32 +- tools/linuxfs/preload/noexec.c | 65 +++ tools/linuxfs/preload/pathcache.c | 7 +- tools/tests/test_binfmt_preload.py | 160 ++++++ tools/tests/test_cdp_guard.py | 3 +- tools/tests/test_desktop_open.py | 521 ++++++++++++++++++ tools/tests/test_droiddeck_fex.py | 9 + tools/tests/test_fsync_preload.py | 2 +- tools/tests/test_noexec_preload.py | 74 +++ tools/tests/test_steam_compat_live.py | 88 +++ tools/tests/test_steam_libraries.py | 13 + 25 files changed, 2135 insertions(+), 28 deletions(-) create mode 100644 tools/linuxfs/overlay/usr/local/bin/droiddeck-open create mode 100644 tools/linuxfs/overlay/usr/local/bin/droiddeck-proton-run create mode 100644 tools/linuxfs/preload/binfmt.c create mode 100644 tools/linuxfs/preload/noexec.c create mode 100644 tools/tests/test_binfmt_preload.py create mode 100644 tools/tests/test_desktop_open.py create mode 100644 tools/tests/test_noexec_preload.py diff --git a/app/src/main/java/com/droiddeck/launcher/runtime/AppImageManager.kt b/app/src/main/java/com/droiddeck/launcher/runtime/AppImageManager.kt index 5c63a0859..201acb1eb 100644 --- a/app/src/main/java/com/droiddeck/launcher/runtime/AppImageManager.kt +++ b/app/src/main/java/com/droiddeck/launcher/runtime/AppImageManager.kt @@ -256,6 +256,20 @@ object AppImageManager { "Terminal=false\nCategories=$categories\nX-DroidDeck-AppImage=$id\n") } + /** The desktop's import of [key]; older ones of the image at [path], since replaced, are removed. */ + fun desktopImport(context: Context, key: String, path: String): String? { + var found: String? = null + root(context).listFiles()?.forEach { dir -> + val asked = FileUtils.readString(File(dir, UserApps.DESKTOP_IMPORT))?.lines() ?: return@forEach + if (asked.firstOrNull() == key) { + if (File(dir, "app").isDirectory) found = dir.name + } else if (asked.getOrNull(1) == path) { + remove(context, dir.name) + } + } + return found + } + fun remove(context: Context, id: String) { if (id.isEmpty() || '/' in id || id.startsWith(".")) return FileUtils.delete(File(root(context), id)) diff --git a/app/src/main/java/com/droiddeck/launcher/runtime/UserApps.kt b/app/src/main/java/com/droiddeck/launcher/runtime/UserApps.kt index 4aee79aaf..21325b936 100644 --- a/app/src/main/java/com/droiddeck/launcher/runtime/UserApps.kt +++ b/app/src/main/java/com/droiddeck/launcher/runtime/UserApps.kt @@ -32,6 +32,8 @@ object UserApps { private const val TAG = "UserApps" const val GUEST_DIR = "/opt/droiddeck-apps" const val SCRIPT_LAUNCHER = "/usr/local/bin/droiddeck-script-run" + /** An app the desktop asked for (droiddeck-open): its key, then the path it was started from there. */ + const val DESKTOP_IMPORT = "desktop-import" private const val FLATPAK_OVERRIDES = ".flatpak" private const val ICON_SIZE = 256 private const val ELF_SCAN_LIMIT = 4000 @@ -72,8 +74,8 @@ object UserApps { class FlatpakBundle(val file: File) : Source() } - /** [icon]: a picked file's path or a suggested icon's URL. */ - class Request(val source: Source, val name: String?, val icon: String?) + /** [icon]: a picked file's path or a suggested icon's URL. [meta]: files written into the added app's folder. */ + class Request(val source: Source, val name: String?, val icon: String?, val meta: Map = emptyMap()) /** How a script's folder reaches the session: linked in place, or copied in ([bytes] to copy). */ class ScriptPlan(val folder: File, val copy: Boolean, val bytes: Long) @@ -121,8 +123,8 @@ object UserApps { val name = request.name?.trim()?.takeIf { it.isNotEmpty() } return withIcon(context, request.icon) { icon -> when (val s = request.source) { - is Source.Script -> addScript(context, s.file, name, icon, onProgress) - is Source.AppImage -> AppImageManager.import(context, s.file, name, icon) { onProgress(it, -1) } + is Source.Script -> addScript(context, s.file, name, icon, request.meta, onProgress) + is Source.AppImage -> AppImageManager.import(context, s.file, name, icon, request.meta) { onProgress(it, -1) } is Source.GitHub -> addFromGitHub(context, s.repo, name, icon, onProgress) is Source.Flatpak -> addFlatpak(context, s.id, name, icon, onProgress) is Source.FlatpakBundle -> addFlatpakBundle(context, s.file, name, icon, onProgress) @@ -197,6 +199,14 @@ object UserApps { }.distinct() } + /** The desktop's import of [key] as the session sees it: an added script's folder, or an AppImage's. */ + fun desktopImport(context: Context, key: String, path: String): String? { + root(context).listFiles()?.firstOrNull { dir -> + File(dir, "entry").isFile && FileUtils.readString(File(dir, DESKTOP_IMPORT))?.lineSequence()?.firstOrNull() == key + }?.let { return "$GUEST_DIR/${it.name}" } + return AppImageManager.desktopImport(context, key, path)?.let { "${AppImageManager.GUEST_DIR}/$it" } + } + fun planScript(script: File): ScriptPlan { val folder = script.canonicalFile.parentFile ?: script.parentFile!! var scanned = 0 @@ -209,7 +219,9 @@ object UserApps { RandomAccessFile(f, "r").use { val b = ByteArray(4); it.read(b) == 4 && b[0] == 0x7f.toByte() && b[1] == 'E'.code.toByte() && b[2] == 'L'.code.toByte() && b[3] == 'F'.code.toByte() } } catch (e: Exception) { false } - private fun addScript(context: Context, script: File, name: String?, icon: File?, onProgress: (String, Int) -> Unit): String? { + private fun addScript( + context: Context, script: File, name: String?, icon: File?, meta: Map, onProgress: (String, Int) -> Unit, + ): String? { if (!script.isFile) return context.getString(R.string.user_apps_file_gone) val plan = planScript(script) val base = root(context).apply { mkdirs() } @@ -232,6 +244,7 @@ object UserApps { FileUtils.writeString(File(dir, "name"), title) FileUtils.writeString(File(dir, "source"), script.canonicalPath) if (icon != null && !saveIcon(icon, File(dir, "icon.png"))) Log.w(TAG, "icon ${icon.path} could not be read") + meta.forEach { (k, v) -> FileUtils.writeString(File(dir, k), v) } writeScriptEntry(context, dir) return null } catch (e: Exception) { 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 954d91b31..7d459bec6 100644 --- a/app/src/main/java/com/droiddeck/launcher/session/SessionFiles.kt +++ b/app/src/main/java/com/droiddeck/launcher/session/SessionFiles.kt @@ -94,6 +94,10 @@ object SessionFiles { // The user's own AppImages, extracted at import (AppImageManager). "usr/local/bin/droiddeck-appimage-run" to "usr/local/bin/droiddeck-appimage-run", "usr/local/bin/droiddeck-script-run" to "usr/local/bin/droiddeck-script-run", + // The desktop's Run entries and its exec fallback: Windows programs through Steam's Proton, + // x86 Linux programs through FEX. + "usr/local/bin/droiddeck-open" to "usr/local/bin/droiddeck-open", + "usr/local/bin/droiddeck-proton-run" to "usr/local/bin/droiddeck-proton-run", // The SteamOS helpers the client calls in Deck mode: the two Armada found it needs, plus // the three under /usr/bin, all no-ops that answer "nothing to do" (see each file). "usr/bin/steamos-update" to "usr/bin/steamos-update", 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 2009b3e24..6472ecc7d 100644 --- a/app/src/main/java/com/droiddeck/launcher/session/SessionService.kt +++ b/app/src/main/java/com/droiddeck/launcher/session/SessionService.kt @@ -38,9 +38,11 @@ import com.droiddeck.launcher.core.HostProcess import com.droiddeck.launcher.frontend.GameLaunchLink import com.droiddeck.launcher.input.FakeInputWriter import com.droiddeck.launcher.input.SteamControllerBle +import com.droiddeck.launcher.runtime.BwrapSpawner import com.droiddeck.launcher.runtime.LinuxNetworkLinkComponent import com.droiddeck.launcher.runtime.LinuxRuntime import com.droiddeck.launcher.runtime.ProotFastPath +import com.droiddeck.launcher.runtime.UserApps import com.droiddeck.launcher.wayland.WaylandCompositor import java.io.File import java.text.SimpleDateFormat @@ -681,7 +683,9 @@ class SessionService : Service() { // changes what games do and leaves the client alone. The microphone is its own opt-in on // top, and the helper only opens an input stream when asked - so a user who wants game // sound but no recording gets exactly that, and Android's recording indicator stays off. - val wantsDirectAudio = SessionState.mode == MODE_STEAM && SessionPrefs.directAudio(this) + // The desktop starts Windows programs through the same Proton wrappers (droiddeck-proton-run). + val wantsDirectAudio = (SessionState.mode == MODE_STEAM || SessionState.mode == MODE_DESKTOP) && + SessionPrefs.directAudio(this) val wantsMic = SessionPrefs.micEnabled(this) && checkSelfPermission(android.Manifest.permission.RECORD_AUDIO) == PackageManager.PERMISSION_GRANTED // Both paths sit under the app's files directory, which the session binds at its own path, @@ -1219,6 +1223,13 @@ class SessionService : Service() { } return } + if (path != null && path.startsWith("desktop-import-") && path.endsWith(".request")) { + val request = File(dir, path) + val text = runCatching { request.readText() }.getOrNull() ?: return + request.delete() + importForDesktop(dir, text) + return + } if (path != "steam-launch") return val file = File(dir, path) val text = try { file.readText() } catch (e: Exception) { return } @@ -1248,6 +1259,48 @@ class SessionService : Service() { launchWatcher = watcher } + private val desktopImports = java.util.concurrent.ConcurrentHashMap() + + /** + * What the desktop cannot run where it lies (droiddeck-open), added as Add an app adds it, menu entry + * included: an AppImage of sharun's, whose hard links Android denies apps and only the app's own proot + * (link2symlink) makes, or a script or program whose folder of Linux programs is on noexec shared + * storage, copied in. The answer goes beside the request, "ok " or "error ". + */ + private fun importForDesktop(dir: File, text: String) { + val fields = text.lineSequence().mapNotNull { line -> + line.split('=', limit = 2).takeIf { it.size == 2 }?.let { it[0] to it[1].trim() } + }.toMap() + val key = fields["id"]?.takeIf { it.matches(Regex("[0-9a-f]{16}")) } ?: return + val guestPath = fields["path"]?.takeIf { it.startsWith("/") && !it.contains("/../") } ?: return + val folder = fields["kind"] == "folder" + val binds = LinuxRuntime.lastBinds(this).map { BwrapSpawner.Bind.parse(it) } + val file = File(BwrapSpawner.hostPath(binds, LinuxRuntime.rootDir(this).path, guestPath)) + val context = applicationContext + // A request for what is already being added waits for that, then finds it. + val lock = desktopImports.computeIfAbsent(key) { Any() } + Thread({ + fun imported() = UserApps.desktopImport(context, key, guestPath)?.let { "ok $it" } + val request = UserApps.Request( + if (folder) UserApps.Source.Script(file) else UserApps.Source.AppImage(file), + if (folder) file.parentFile?.name else null, null, mapOf(UserApps.DESKTOP_IMPORT to "$key\n$guestPath"), + ) + val answer = synchronized(lock) { + try { + imported() ?: UserApps.add(context, request) { _, _ -> }?.let { "error $it" } + ?: imported() ?: "error " + context.getString(R.string.user_apps_failed) + } catch (e: Exception) { + Log.e(TAG, "Desktop import of $guestPath", e) + "error " + (e.message ?: context.getString(R.string.user_apps_failed)) + } + } + Log.i(TAG, "Desktop import of $guestPath: $answer") + val result = File(dir, "desktop-import-$key.result") + val partial = File(dir, result.name + ".tmp") + runCatching { partial.writeText(answer.replace('\n', ' ') + "\n"); partial.renameTo(result) } + }, "desktop-import").start() + } + @Volatile private var syncWatcher: android.os.FileObserver? = null private fun watchSyncWanted(root: File) { diff --git a/tools/linuxfs/desktop/droiddeck-desktop b/tools/linuxfs/desktop/droiddeck-desktop index 6fb8c1a72..4b3105bc1 100644 --- a/tools/linuxfs/desktop/droiddeck-desktop +++ b/tools/linuxfs/desktop/droiddeck-desktop @@ -38,6 +38,8 @@ export MOZ_SHM_NO_SEALS=1 # to the app as a Steam session - SteamOS's "Return to Gaming Mode". The session's own GL choice # (zink on Turnip, for the Steam client) is put back by droiddeck-gpu. export KWIN_COMPOSE=Q QT_QUICK_BACKEND=software LIBGL_ALWAYS_SOFTWARE=1 GALLIUM_DRIVER=llvmpipe +# mpv refuses that software GL and then fails its X11 fallback (an assertion): allowed it, it plays. +[ -e /etc/mpv/mpv.conf ] || { mkdir -p /etc/mpv && echo gpu-sw=yes >/etc/mpv/mpv.conf; } 2>/dev/null export DROIDDECK_NESTED_SCALE=1 export DROIDDECK_GLTHREAD=${mesa_glthread:-} unset MESA_LOADER_DRIVER_OVERRIDE LIBGL_KOPPER_DRI2 mesa_glthread @@ -75,6 +77,13 @@ python3 /usr/local/bin/droiddeck-pad-defaults 2>&1 | sed 's/^/[pads] /' python3 /usr/local/bin/droiddeck-desktop-gpu 2>&1 | sed 's/^/[gpu] /' # The windowed action still opens melonDS at the size/placement the LXQt desktop used. /usr/local/bin/droiddeck-desktop-window-rules 2>&1 | sed 's/^/[rules] /' +# Windows programs, Linux programs, AppImages and scripts open with droiddeck-open (Steam's Proton, +# FEX for x86); an exec the kernel refuses is handed to it as well (libblsession's binfmt.c). An +# AppImage run directly cannot mount itself under proot, so it unpacks itself to run. +python3 /usr/local/bin/droiddeck-open --install 2>&1 | sed 's/^/[open] /' +export APPIMAGE_EXTRACT_AND_RUN=1 +# A click runs an executable script or program without KIO asking first; Dolphin's settings can still ask. +[ -e /etc/xdg/kiorc ] || printf '[Executable scripts]\nbehaviourOnLaunch=execute\n' >/etc/xdg/kiorc 2>/dev/null # SteamOS's desktop icons: Return to Gaming Mode and Steam, put there once - what the user moves # or deletes stays that way. desktop_dir=$(xdg-user-dir DESKTOP 2>/dev/null); [ -n "$desktop_dir" ] && [ "$desktop_dir" != "$HOME" ] || desktop_dir=$HOME/Desktop diff --git a/tools/linuxfs/overlay/usr/local/bin/droiddeck-desktop-games b/tools/linuxfs/overlay/usr/local/bin/droiddeck-desktop-games index 21cd87d16..0773601f0 100755 --- a/tools/linuxfs/overlay/usr/local/bin/droiddeck-desktop-games +++ b/tools/linuxfs/overlay/usr/local/bin/droiddeck-desktop-games @@ -12,12 +12,14 @@ import sys HOME = os.environ.get("HOME", "/root") STEAM_ROOT = sys.argv[1] if len(sys.argv) > 1 else os.path.join(HOME, ".local/share/Steam") LIBRARIES = ((STEAM_ROOT, "Steam Games"), ("/mnt/droiddeck-sd", "SD Games")) -# The client's own tools and runtimes live in steamapps beside the games; they are not titles. -NOT_GAMES = {228980, 1493710, 3127680, 4183110, 4427310, 4185400} +# The client's own tools and runtimes live in steamapps beside the games; they are not titles. A +# depot with a toolmanifest.vdf is one too (a runtime or a Proton), listed here or not. +NOT_GAMES = {228980, 1070560, 1391110, 1493710, 1628350, 3127680, 4183110, 4185400, 4427310, 4628740} APPS_DIR = os.path.join(HOME, ".local/share/applications") PREFIX = "droiddeck-game-" NAME = re.compile(r'^\s*"name"\s*"([^"]*)"', re.M) STATE = re.compile(r'^\s*"StateFlags"\s*"(\d+)"', re.M) +INSTALLDIR = re.compile(r'^\s*"installdir"\s*"([^"]*)"', re.M) def games(library): @@ -42,6 +44,9 @@ def games(library): # StateFlags 4 = fully installed; anything else is downloading, updating or broken. if not name or not state or (int(state.group(1)) & 4) == 0: continue + installdir = INSTALLDIR.search(text) + if installdir and os.path.isfile(os.path.join(steamapps, "common", installdir.group(1), "toolmanifest.vdf")): + continue out.append((appid, name.group(1))) return out diff --git a/tools/linuxfs/overlay/usr/local/bin/droiddeck-fex b/tools/linuxfs/overlay/usr/local/bin/droiddeck-fex index 4eb01ca5a..4a5967012 100755 --- a/tools/linuxfs/overlay/usr/local/bin/droiddeck-fex +++ b/tools/linuxfs/overlay/usr/local/bin/droiddeck-fex @@ -406,12 +406,22 @@ def split_paths(value): return [part for part in re.split(r"[:\s]+", value or "") if part] +def data_dir(env): + # FEXServer's socket lives here. Under ~/.local its host path passes sun_path's 108 bytes, and + # proot then binds it to a temporary name only the server sees: no client ever reaches it. + runtime = env.get("XDG_RUNTIME_DIR") + if runtime and os.path.isdir(runtime) and os.access(runtime, os.W_OK): + return os.path.join(runtime, "fex") + return DATA_DIR + + def guest_environment(fex, env): result = dict(env) - for directory in (CONFIG_DIR, DATA_DIR, CACHE_DIR): + data = data_dir(env) + for directory in (CONFIG_DIR, data, CACHE_DIR): os.makedirs(directory, exist_ok=True) result["FEX_APP_CONFIG_LOCATION"] = CONFIG_DIR + "/" - result["FEX_APP_DATA_LOCATION"] = DATA_DIR + "/" + result["FEX_APP_DATA_LOCATION"] = data + "/" result["FEX_APP_CACHE_LOCATION"] = CACHE_DIR + "/" result.setdefault("FEX_SILENTLOG", "0") result.setdefault("FEX_OUTPUTLOG", "stderr") diff --git a/tools/linuxfs/overlay/usr/local/bin/droiddeck-open b/tools/linuxfs/overlay/usr/local/bin/droiddeck-open new file mode 100644 index 000000000..3ceb080df --- /dev/null +++ b/tools/linuxfs/overlay/usr/local/bin/droiddeck-open @@ -0,0 +1,434 @@ +#!/usr/bin/python3 +"""Runs a program from the desktop: a Windows program through the Proton Steam has chosen, a Linux +program (x86 ones under FEX), an AppImage, or a script (under FEX beside x86 programs, as a game's +start script is). Shared storage is noexec: FEX runs x86 programs there where they lie (libblsession's +noexec.c), while a native one is copied - alone into the cache, or with its folder by the app once (as +Add an app does) when that holds native programs or libraries. A Steam library's games are Steam's. + + droiddeck-open [--window | --terminal] FILE [ARGS...] the file manager's Run entries + droiddeck-open --exec FILE [ARGS...] an exec the kernel refused (libblsession) + droiddeck-open --install the Run entries and default handlers + +The desktop composites in software, so a program started from it goes full screen on the GPU +(droiddeck-gpu), as the menu's games do: --window keeps it in a desktop window instead, --terminal +runs it in Konsole. A plain script stays on the desktop, and an exec whose output is read (a terminal, +a pipe, a file) stays where it was started. +""" +import fcntl +import hashlib +import os +import runpy +import shutil +import stat +import subprocess +import sys +import time + +HOME = os.environ.get("HOME") or "/root" +BIN = "/usr/local/bin" +FEX = os.path.join(BIN, "droiddeck-fex") +GPU = os.path.join(BIN, "droiddeck-gpu") +PROTON_RUN = os.path.join(BIN, "droiddeck-proton-run") +APPIMAGE_RUN = os.path.join(BIN, "droiddeck-appimage-run") +SCRIPT_RUN = os.path.join(BIN, "droiddeck-script-run") +STEAM_LAUNCH = os.path.join(BIN, "droiddeck-steam-launch") +CACHE = os.path.join(HOME, ".cache", "droiddeck") +# Where the app adds each kind, and what an added one holds. +IMPORTS = {"appimage": ("/opt/appimages/user", "app"), "folder": ("/opt/droiddeck-apps", "entry")} +# Android's own folders on shared storage: never copied in whole. +SHARED_FOLDERS = ("alarms", "android", "audiobooks", "dcim", "documents", "download", "movies", "music", + "notifications", "pictures", "podcasts", "recordings", "ringtones") +SCAN_LIMIT = 4000 +APPS_DIR = "/usr/local/share/applications" +WINDOWS = (".exe", ".bat", ".cmd", ".com", ".msi") +NOT_PROGRAMS = (".dll", ".sys", ".drv", ".cpl", ".ocx", ".efi", ".scr", ".mui") +SCRIPTS = (".sh", ".bash") +MACHINES = {3: "i386", 62: "x86_64", 183: "arm64"} +EMULATED = (3, 62) +QUICK_FAILURE = 20 +IMPORT_WAIT = 1800 +WINDOWS_TYPES = ("application/x-ms-dos-executable", "application/x-msdownload", + "application/vnd.microsoft.portable-executable", "application/x-msi", "application/x-bat") +SCRIPT_TYPES = ("application/x-shellscript", "text/x-shellscript") +LINUX_TYPES = ("application/x-executable", "application/x-pie-executable", "application/vnd.appimage") +ENTRIES = ( + ("droiddeck-open.desktop", "Run", "", WINDOWS_TYPES + SCRIPT_TYPES + LINUX_TYPES), + ("droiddeck-open-window.desktop", "Run in a Desktop Window", "--window ", WINDOWS_TYPES + SCRIPT_TYPES + LINUX_TYPES), + ("droiddeck-open-terminal.desktop", "Run in Konsole", "--terminal ", SCRIPT_TYPES + LINUX_TYPES), +) + + +def say(message): + print("droiddeck-open: %s" % message, file=sys.stderr, flush=True) + + +def notify(title, body, icon="dialog-error"): + if not os.environ.get("DBUS_SESSION_BUS_ADDRESS") or not shutil.which("notify-send"): + return + try: + subprocess.run(["notify-send", "-a", "DroidDeck", "-i", icon, title, body], + stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, timeout=5) + except (OSError, subprocess.SubprocessError): + pass + + +def head(path, size=64): + try: + with open(path, "rb") as f: + return f.read(size) + except OSError: + return b"" + + +def machine(data): + if len(data) < 20 or data[:4] != b"\x7fELF": + return None + return int.from_bytes(data[18:20], "big" if data[5] == 2 else "little") + + +def kind(path): + data = head(path) + ext = os.path.splitext(path)[1].lower() + if data[:4] == b"\x7fELF": + return "appimage" if data[8:11] == b"AI\x02" or ext == ".appimage" else "elf" + if ext in NOT_PROGRAMS: + return None + if ext in WINDOWS or data[:2] == b"MZ": + return "windows" + if data[:2] == b"#!" or ext in SCRIPTS: + return "script" + return None + + +def noexec(path): + try: + return bool(os.statvfs(path).f_flag & os.ST_NOEXEC) + except OSError: + return False + + +def interpreter(path): + line = head(path, 256).split(b"\n", 1)[0].rstrip(b"\r") + if line.startswith(b"#!"): + words = line[2:].decode("utf-8", "replace").split() + if words: + return words + return ["/bin/bash"] + + +def for_x86(script): + return subprocess.call([FEX, "needs", os.path.dirname(script)], stdout=subprocess.DEVNULL, + stderr=subprocess.DEVNULL) == 0 + + +def runnable(path): + """The program itself, or a copy in the cache of a native one on noexec storage.""" + if not noexec(path) or machine(head(path)) in EMULATED: + return path + st = os.stat(path) + key = hashlib.sha1(os.path.realpath(path).encode("utf-8")).hexdigest()[:16] + copy = os.path.join(CACHE, "exec", key, os.path.basename(path)) + try: + same = os.stat(copy) + if same.st_size == st.st_size and same.st_mtime_ns == st.st_mtime_ns: + return copy + except OSError: + pass + os.makedirs(os.path.dirname(copy), exist_ok=True) + shutil.copyfile(path, copy + ".tmp") + os.utime(copy + ".tmp", ns=(st.st_atime_ns, st.st_mtime_ns)) + os.chmod(copy + ".tmp", 0o755) + os.replace(copy + ".tmp", copy) + return copy + + +def appimage(path): + """The image unpacked once into the cache, laid out as droiddeck-appimage-run expects.""" + st = os.stat(path) + real = os.path.realpath(path) + key = hashlib.sha1(("%s\0%d\0%d" % (real, st.st_size, st.st_mtime_ns)).encode("utf-8")).hexdigest()[:16] + images = os.path.join(CACHE, "appimages") + return once(key, lambda: unpacked(path, real, key, images, os.path.join(images, key))) + + +def once(key, make): + """[make]() for [key] one start at a time: a second start waits for the first, then finds it done.""" + locks = os.path.join(CACHE, "locks") + os.makedirs(locks, exist_ok=True) + with open(os.path.join(locks, key), "w") as lock: + fcntl.flock(lock, fcntl.LOCK_EX) + return make() + + +def unpacked(path, real, key, images, folder): + if os.path.exists(os.path.join(folder, "app", "AppRun")): + return folder + earlier = import_of(key, "appimage") + if earlier: + return earlier + name = os.path.splitext(os.path.basename(path))[0] + notify("Preparing %s" % name, "Unpacking it for its first start.", "system-run") + work = folder + ".tmp" + shutil.rmtree(work, ignore_errors=True) + os.makedirs(work) + status = subprocess.call([FEX, "extract", real], cwd=work, stdout=subprocess.DEVNULL) + unpacked = os.path.realpath(os.path.join(work, "squashfs-root")) + if status != 0 or not os.path.isdir(unpacked): + shutil.rmtree(work, ignore_errors=True) + return imported("appimage", real, key, name) + os.replace(unpacked, os.path.join(work, "app")) + if os.path.islink(os.path.join(work, "squashfs-root")): + os.unlink(os.path.join(work, "squashfs-root")) + for file, value in (("name", name), ("arch", MACHINES.get(machine(head(path)), "")), ("source", real)): + with open(os.path.join(work, file), "w", encoding="utf-8") as f: + f.write(value + "\n") + for other in os.listdir(images): + old = os.path.join(images, other) + if other != key + ".tmp" and (head(os.path.join(old, "source"), 4096).decode("utf-8", "replace").strip() == real): + shutil.rmtree(old, ignore_errors=True) + os.replace(work, folder) + return folder + + +def import_of(key, what): + root, made = IMPORTS[what] + try: + entries = sorted(os.listdir(root)) + except OSError: + return None + for entry in entries: + folder = os.path.join(root, entry) + if head(os.path.join(folder, "desktop-import"), 64).split(b"\n", 1)[0] == key.encode() \ + and os.path.exists(os.path.join(folder, made)): + return folder + return None + + +def imported(what, real, key, name): + """[real] added by the app instead, as Add an app adds it (to the menu too): an AppImage whose hard + links (sharun's) only the app's own proot can make, or a folder of native programs off noexec storage.""" + launch = os.environ.get("BL_LAUNCH_DIR") + if not launch or not os.path.isdir(launch): + raise RuntimeError("%s cannot run from here; add it in DroidDeck with Add an app." % name) + result = os.path.join(launch, "desktop-import-%s.result" % key) + request = os.path.join(launch, "desktop-import-%s.request" % key) + with open(request + ".tmp", "w", encoding="utf-8") as f: + f.write("id=%s\nkind=%s\npath=%s\n" % (key, what, real)) + os.replace(request + ".tmp", request) + if what == "appimage": + notify("Adding %s to DroidDeck" % name, "It is unpacked once, then it starts, and it stays in the menu.", "system-run") + else: + notify("Adding %s to DroidDeck" % name, "Shared storage cannot run its programs, so the folder is copied in " + "once; then it starts, and it stays in the menu.", "system-run") + deadline = time.monotonic() + IMPORT_WAIT + while time.monotonic() < deadline: + try: + with open(result, encoding="utf-8") as f: + answer = f.read().strip() + except OSError: + time.sleep(1) + continue + os.unlink(result) + verdict, _, detail = answer.partition(" ") + if verdict == "ok" and os.path.exists(os.path.join(detail, IMPORTS[what][1])): + return detail + raise RuntimeError(detail or "DroidDeck could not add %s." % name) + raise RuntimeError("DroidDeck did not finish adding %s." % name) + + +def game_folder(path): + """The folder of [path] when it runs only from a copy: on noexec storage, holding native programs or + libraries (besides [path]) that it starts or loads. Not the storage itself, one of Android's folders + or a Steam library.""" + real = os.path.realpath(path) + folder = os.path.dirname(real) + if in_steam_library(real) or not noexec(folder): + return None + top = storage_root(folder) + parts = os.path.relpath(folder, top).split(os.sep) + if folder == top or (len(parts) == 1 and parts[0].lower() in SHARED_FOLDERS): + return None + seen = 0 + for root, dirs, files in os.walk(folder): + if root[len(folder):].count(os.sep) >= 3: + dirs[:] = [] + for name in files: + child = os.path.join(root, name) + if child == real: + continue + seen += 1 + if seen > SCAN_LIMIT: + return None + if machine(head(child)) not in (None,) + EMULATED: + return folder + return None + + +def in_steam_library(path): + """Whether [path] is in a Steam library: its games are Steam's to start, never copied in.""" + return "steamapps" in os.path.realpath(path).lower().split(os.sep) + + +def storage_root(folder): + """The top of the storage [folder] is on: the last folder above it on the same file system.""" + top = folder + try: + dev = os.stat(folder).st_dev + while os.path.dirname(top) != top and os.stat(os.path.dirname(top)).st_dev == dev: + top = os.path.dirname(top) + except OSError: + pass + return top + + +def copied_in(path): + """The app's copy of [path]'s folder, added (once) for it.""" + real = os.path.realpath(path) + key = hashlib.sha1(("folder\0%s" % real).encode("utf-8")).hexdigest()[:16] + name = os.path.basename(os.path.dirname(real)) + return once(key, lambda: import_of(key, "folder") or imported("folder", real, key, name)) + + +def steam_title(path): + """The Steam game [path] is the program of: Steam starts it, with the client most games need.""" + try: + run = runpy.run_path(PROTON_RUN) + root = os.environ.get("STEAM_COMPAT_CLIENT_INSTALL_PATH") or run["STEAM_ROOT"] + target = run["locate"](path, root) + return target.appid if run["steam_launches"](target, path, root) else None + except (OSError, ValueError, KeyError, IndexError): + return None + + +def command(path, args, what, window=False, appid=None): + """(command, working directory) that runs [path] in place.""" + folder = os.path.dirname(path) + if what == "steam": + return [STEAM_LAUNCH, "desktop", appid], folder + if what == "windows": + return [PROTON_RUN] + (["--window"] if window else []) + [path] + args, folder + if what == "x86 script": + return [FEX, "run", "--mode", "on", "--for", folder, "--"] + interpreter(path) + [path] + args, folder + if what == "script": + return interpreter(path) + [path] + args, folder + if what == "appimage": + return [APPIMAGE_RUN, appimage(path)] + args, folder + if what == "folder": + return [SCRIPT_RUN, copied_in(path)] + args, folder + return [FEX, "run", "--mode", "auto", "--", runnable(path)] + args, folder + + +def on_desktop(env): + return env.get("BL_DESKTOP") == "1" and not env.get("GAMESCOPE_WAYLAND_DISPLAY") and os.access(GPU, os.X_OK) + + +def unattended(env): + """Nobody reads the output: it goes to /dev/null or the desktop's log, as from Dolphin or the menu.""" + try: + out = os.fstat(1) + except OSError: + return True + if stat.S_ISCHR(out.st_mode): + return not os.isatty(1) + folder = env.get("BL_DEBUG_DIR") + try: + log = os.stat(os.path.join(folder, "desktop.log")) if folder else None + except OSError: + log = None + return log is not None and (log.st_dev, log.st_ino) == (out.st_dev, out.st_ino) + + +def placed(cmd, what, mode, env): + """[cmd] where it shows: full screen on the GPU from the desktop, else where it was started.""" + if mode == "terminal" and what not in ("windows", "steam") and shutil.which("konsole"): + return ["konsole", "--hold", "-e"] + cmd + if mode == "window" or what in ("script", "steam") or not on_desktop(env): + return cmd + if mode == "exec" and what != "windows" and not unattended(env): + return cmd + return [GPU] + cmd + + +def install(directory=APPS_DIR): + os.makedirs(directory, exist_ok=True) + defaults = [] + for file, name, option, types in ENTRIES: + body = ("[Desktop Entry]\nType=Application\nName=%s\nIcon=system-run\nExec=%s %s%%f\nTerminal=false\n" + "NoDisplay=true\nMimeType=%s;\n" % (name, os.path.join(BIN, "droiddeck-open"), option, ";".join(types))) + write(os.path.join(directory, file), body) + for mime in WINDOWS_TYPES + SCRIPT_TYPES + LINUX_TYPES: + defaults.append("%s=%s" % (mime, ENTRIES[0][0])) + added = ["%s=%s" % (mime, ";".join(f for f, _, _, types in ENTRIES if mime in types) + ";") + for mime in WINDOWS_TYPES + SCRIPT_TYPES + LINUX_TYPES] + write(os.path.join(directory, "mimeapps.list"), + "[Default Applications]\n%s\n\n[Added Associations]\n%s\n" % ("\n".join(defaults), "\n".join(added))) + return 0 + + +def write(path, text): + try: + with open(path, encoding="utf-8") as f: + if f.read() == text: + return + except OSError: + pass + with open(path + ".tmp", "w", encoding="utf-8") as f: + f.write(text) + os.replace(path + ".tmp", path) + + +def main(argv): + mode = "run" + if argv and argv[0] == "--install": + return install() + if argv and argv[0] in ("--window", "--terminal", "--exec"): + mode = argv.pop(0)[2:] + if argv and argv[0] == "--": + argv.pop(0) + if not argv: + say("usage: droiddeck-open [--window | --terminal | --exec] FILE [ARGS...] | --install") + return 2 + path = os.path.abspath(argv[0]) + what = kind(path) + if what is None: + say("%s is not a program this desktop can run" % path) + if mode != "exec": + notify("Cannot run %s" % os.path.basename(path), "It is not a Windows or Linux program or a script.") + return 126 + linux_game = what in ("script", "elf") and mode == "run" and in_steam_library(path) + appid = steam_title(path) if (what == "windows" and mode != "window") or linux_game else None + if appid: + what = "steam" + elif what == "script" and for_x86(path): + what = "x86 script" + elif what in ("script", "elf") and game_folder(path): + what = "folder" + try: + cmd, folder = command(path, argv[1:], what, mode == "window", appid) + except (OSError, RuntimeError) as error: + say(str(error)) + notify("Cannot run %s" % os.path.basename(path), str(error)) + return 126 + cmd = placed(cmd, what, mode, os.environ) + if mode != "exec" or not sys.stderr.isatty(): + say("%s (%s): %s" % (path, what, " ".join(cmd[:4]))) + try: + os.chdir(folder) + except OSError: + pass + if mode == "exec": + os.execv(cmd[0], cmd) + started = time.monotonic() + try: + status = subprocess.call(cmd) + except OSError as error: + status = 127 + say("%s: %s" % (cmd[0], error)) + if status != 0 and time.monotonic() - started < QUICK_FAILURE: + notify("%s did not start" % os.path.basename(path), + "It exited with status %d; the session's desktop.log says why." % status) + return status + + +if __name__ == "__main__": + sys.exit(main(sys.argv[1:])) diff --git a/tools/linuxfs/overlay/usr/local/bin/droiddeck-proton-run b/tools/linuxfs/overlay/usr/local/bin/droiddeck-proton-run new file mode 100644 index 000000000..8ff6f14ee --- /dev/null +++ b/tools/linuxfs/overlay/usr/local/bin/droiddeck-proton-run @@ -0,0 +1,331 @@ +#!/usr/bin/python3 +"""Runs a Windows program with the Proton the Steam client has chosen for it. + + droiddeck-proton-run [--window] PROGRAM [ARGS...] + +The program belongs to an installed Steam game when it sits in one's folder, to a prefix when it +sits in one's drive_c, or to a non-Steam shortcut that names it; any other program gets a prefix of +its own, under the id the client gives a new shortcut. That title's CompatToolMapping entry in +config.vdf picks the tool, else the client's default for all other titles ("0"). The tool is +started as the client starts it - its toolmanifest's command line, the waitforexitandrun verb and +the STEAM_COMPAT_* environment - so its wrapper applies the game's settings, components and audio. +--window keeps the program in the desktop's own window, drawn with WineD3D. +""" +import json +import os +import re +import runpy +import struct +import sys +import zlib + +HOME = os.environ.get("HOME") or "/root" +STEAM_ROOT = os.path.join(HOME, ".local", "share", "Steam") +BIN_DIR = os.path.dirname(os.path.abspath(__file__)) +STATE = os.path.join(HOME, ".local", "share", "droiddeck-compat", "state.json") +EXTRA_LIBRARIES = ("/mnt/droiddeck", "/mnt/droiddeck-sd") +SYSTEM_TOOLS = ("/usr/share/steam/compatibilitytools.d", "/usr/local/share/steam/compatibilitytools.d") +VERB = "waitforexitandrun" +SHORTCUT_BIT = 0x80000000 +STEAM_APP_LIMIT = 2 ** 31 + +_compat = None + + +def say(message): + print("droiddeck-proton-run: %s" % message, file=sys.stderr, flush=True) + + +def compat(): + global _compat + if _compat is None: + _compat = runpy.run_path(os.path.join(BIN_DIR, "steam-compatibility")) + return _compat + + +def read_text(path): + try: + with open(path, encoding="utf-8", errors="replace") as f: + return f.read() + except OSError: + return None + + +def libraries(root): + found, seen = [], set() + for library in compat()["libraries"](root) + list(EXTRA_LIBRARIES): + try: + key = os.stat(os.path.join(library, "steamapps")) + except OSError: + continue + if (key.st_dev, key.st_ino) not in seen: + seen.add((key.st_dev, key.st_ino)) + found.append(library) + return found + + +def mapping(root): + text = read_text(os.path.join(root, "config", "config.vdf")) + if not text: + return {} + c = compat() + tokens = c["tokenize"](text) + steam = c["find_block"](tokens, ["InstallConfigStore", "Software", "Valve", "Steam"]) + if steam is None: + return {} + block = c["find_block"](tokens[steam + 1:], ["CompatToolMapping"]) + return {} if block is None else c["read_mapping"](tokens, block + steam + 1) + + +def tools(root): + """Windows compatibility tools this runtime can start, by the name config.vdf uses.""" + found = {} + for base in [os.path.join(root, "compatibilitytools.d")] + list(SYSTEM_TOOLS): + try: + entries = sorted(os.listdir(base)) + except OSError: + continue + for entry in entries: + folder = os.path.join(base, entry) + vdf = os.path.join(folder, "compatibilitytool.vdf") + if not re.search(r'"from_oslist"\s+"[^"]*windows', read_text(vdf) or "", re.I): + continue + command = compat()["manifest_entry_point"](os.path.join(folder, "toolmanifest.vdf")) + if not command or not os.access(os.path.join(folder, command), os.X_OK): + continue + name = compat()["first_key"](vdf, ["compatibilitytools", "compat_tools"]) or entry + found.setdefault(name, (folder, command)) + return found + + +def state_default(): + try: + with open(STATE, encoding="utf-8") as f: + value = json.load(f).get("default") + return value if isinstance(value, str) else None + except (OSError, ValueError, AttributeError): + return None + + +def choose_tool(appid, current, available): + """(tool name, why) from the client's mapping, else the session's own default.""" + for key, why in ((appid, "Steam's choice for this title"), ("0", "Steam's default")): + name = current.get(key) + if name in available: + return name, why + c = compat() + for name in (state_default(), c["TOOL"], c["TOOL_11"]): + if name in available: + return name, "the default ARM64 Proton" + return (sorted(available)[0], "the only one installed") if available else (None, None) + + +class Target: + def __init__(self, appid, compatdata, install, library, kind, start=None): + self.appid = str(appid) + self.compatdata = compatdata + self.install = install + self.library = library + self.kind = kind + self.start = start or install + + +def ancestors(path): + """(folder, the entry below it on the way to path) from the program's folder up to /.""" + child, folder = path, os.path.dirname(path) + while True: + yield folder, os.path.basename(child) + if folder == os.path.dirname(folder): + return + child, folder = folder, os.path.dirname(folder) + + +def identity(path): + try: + st = os.stat(path) + return st.st_dev, st.st_ino + except OSError: + return None + + +def installed_app(steamapps, installdir): + for name in sorted(os.listdir(steamapps)): + m = re.fullmatch(r"appmanifest_(\d+)\.acf", name) + if not m: + continue + found = re.search(r'"installdir"\s+"([^"]+)"', read_text(os.path.join(steamapps, name)) or "") + if found and found.group(1).lower() == installdir.lower(): + return m.group(1) + return None + + +def steam_game(program, libs): + commons = {} + for library in libs: + key = identity(os.path.join(library, "steamapps", "common")) + if key: + commons.setdefault(key, library) + for folder, below in ancestors(program): + library = commons.get(identity(folder)) + if library is None: + continue + appid = installed_app(os.path.join(library, "steamapps"), below) + if appid is None or appid in compat()["NOT_GAMES"]: + return None + return Target(appid, os.path.join(library, "steamapps", "compatdata", appid), + os.path.join(folder, below), library, "steam") + return None + + +def prefix_of(program): + for folder, below in ancestors(program): + parent = os.path.dirname(folder) + if below == "pfx" and os.path.basename(parent) == "compatdata" and os.path.basename(folder).isdigit(): + library = os.path.dirname(os.path.dirname(parent)) + return Target(os.path.basename(folder), folder, os.path.dirname(program), library, "prefix") + return None + + +def unquoted(value): + return value.strip().strip('"') if isinstance(value, str) else "" + + +def same_file(a, b): + try: + return bool(b) and os.path.samefile(a, b) + except OSError: + return False + + +def shortcut_entries(root): + """(appid, exe, start dir) of the client's non-Steam shortcuts and the app's added games.""" + entries = [] + try: + tool = runpy.run_path(os.path.join(BIN_DIR, "droiddeck-steam-shortcuts")) + account = tool["account_dir"](root) + if account: + with open(os.path.join(account, "config", "shortcuts.vdf"), "rb") as f: + shortcuts = tool["parse"](f.read()).get("shortcuts", {}) + for value in shortcuts.values(): + if not isinstance(value, dict): + continue + appid = value.get("appid", value.get("AppId")) + exe = value.get("Exe", value.get("exe")) + if isinstance(appid, int) and exe: + entries.append((appid & 0xFFFFFFFF, unquoted(exe), unquoted(value.get("StartDir", "")))) + except (OSError, ValueError, IndexError, KeyError, struct.error): + pass + try: + with open(os.environ.get("BL_ADDED_GAMES", ""), encoding="utf-8") as f: + for game in json.load(f): + if isinstance(game, dict) and game.get("exe") and str(game.get("appid", "")).isdigit(): + entries.append((int(game["appid"]) & 0xFFFFFFFF, game["exe"], game.get("dir") or "")) + except (OSError, ValueError, TypeError): + pass + return entries + + +def shortcut(program, root): + for appid, exe, start in shortcut_entries(root): + if same_file(program, exe): + return Target(appid, os.path.join(root, "steamapps", "compatdata", str(appid)), + os.path.dirname(program), root, "shortcut", start if os.path.isdir(start) else None) + return None + + +def own_id(program): + """The id the client gives a new shortcut: the CRC of its quoted target and its name.""" + name = os.path.splitext(os.path.basename(program))[0] + return zlib.crc32(('"%s"%s' % (program, name)).encode("utf-8")) | SHORTCUT_BIT + + +def locate(program, root): + libs = libraries(root) + found = steam_game(program, libs) or prefix_of(program) or shortcut(program, root) + if found: + return found + appid = own_id(program) + return Target(appid, os.path.join(root, "steamapps", "compatdata", str(appid)), + os.path.dirname(program), root, "own") + + +def steam_launches(target, program, root): + """Whether a launch option of the Steam game starts [program]: then Steam should start it.""" + if target.kind != "steam": + return False + entry = compat()["appinfo_entries"](os.path.join(root, "appcache", "appinfo.vdf")).get(target.appid, {}) + return os.path.relpath(program, target.install).replace(os.sep, "/").lower() in entry.get("launch", ()) + + +def environment(env, target, tool_folder, root, window=False): + env = dict(env) + steamapps = [os.path.join(lib, "steamapps") for lib in libraries(root)] + env.update({ + "STEAM_COMPAT_DATA_PATH": target.compatdata, + "STEAM_COMPAT_CLIENT_INSTALL_PATH": root, + "STEAM_COMPAT_INSTALL_PATH": target.install, + "STEAM_COMPAT_LIBRARY_PATHS": ":".join(steamapps), + "STEAM_COMPAT_TOOL_PATHS": tool_folder, + "STEAM_COMPAT_SHADER_PATH": os.path.join(target.library, "steamapps", "shadercache", target.appid), + }) + number = int(target.appid) + if number < STEAM_APP_LIMIT: + env.update(SteamAppId=target.appid, SteamGameId=target.appid, SteamOverlayGameId=target.appid, + STEAM_COMPAT_APP_ID=target.appid) + else: + game = str(number << 32 | 0x02000000) + env.update(SteamAppId="0", STEAM_COMPAT_APP_ID="0", SteamGameId=game, SteamOverlayGameId=game) + if window: + env.setdefault("PROTON_USE_WINED3D", "1") + return env + + +def windows_path(path): + return "Z:" + path.replace("/", "\\") + + +def arguments(program, args): + if program.lower().endswith(".msi"): + return ["msiexec", "/i", windows_path(program)] + args + return [program] + args + + +def main(argv): + window = False + while argv and argv[0].startswith("--"): + option = argv.pop(0) + if option == "--window": + window = True + elif option == "--": + break + else: + say("unknown option %s" % option) + return 2 + if not argv: + say("usage: droiddeck-proton-run [--window] PROGRAM [ARGS...]") + return 2 + program = os.path.abspath(argv[0]) + if not os.path.isfile(program): + say("%s does not exist" % program) + return 2 + root = os.environ.get("STEAM_COMPAT_CLIENT_INSTALL_PATH") or STEAM_ROOT + target = locate(program, root) + available = tools(root) + name, why = choose_tool(target.appid, mapping(root), available) + if name is None: + say("no Proton is installed yet; open Steam once and it is downloaded for you") + return 69 + folder, command = available[name] + os.makedirs(target.compatdata, exist_ok=True) + env = environment(os.environ, target, folder, root, window) + say("%s with %s (%s), %s prefix %s" % (program, name, why, target.kind, target.compatdata)) + try: + os.chdir(target.start) + except OSError: + os.chdir(os.path.dirname(program)) + entry = os.path.join(folder, command) + os.execve(entry, [entry, VERB] + arguments(program, argv[1:]), env) + + +if __name__ == "__main__": + sys.exit(main(sys.argv[1:])) diff --git a/tools/linuxfs/overlay/usr/local/bin/droiddeck-script-run b/tools/linuxfs/overlay/usr/local/bin/droiddeck-script-run index f512be638..c4dd30c57 100755 --- a/tools/linuxfs/overlay/usr/local/bin/droiddeck-script-run +++ b/tools/linuxfs/overlay/usr/local/bin/droiddeck-script-run @@ -12,14 +12,15 @@ first= IFS= read -r first < "$entry" first=${first%$'\r'} interp=(/bin/bash) -case $first in '#!'*) read -r -a interp <<< "${first#'#!'}" ;; esac +# A program as the entry (the desktop's copy of a game's folder) runs itself. +case $first in '#!'*) read -r -a interp <<< "${first#'#!'}" ;; $'\x7f'ELF*) interp=() ;; esac fex=$(cat "$dir/fex" 2>/dev/null) case $fex in on|off) ;; *) fex=auto ;; esac run=("${interp[@]}" "./$entry") if [ -x /usr/local/bin/droiddeck-fex ]; then run=(/usr/local/bin/droiddeck-fex run --mode "$fex" --for "$folder" -- "${interp[@]}" "./$entry") fi -echo "== script $entry in $folder (${interp[*]}, FEX $fex)" +echo "== script $entry in $folder (${interp[*]:-a program}, FEX $fex)" case ${DBUS_SESSION_BUS_ADDRESS:-} in unix:*) "${run[@]}" "$@" ;; *) unset DBUS_SESSION_BUS_ADDRESS diff --git a/tools/linuxfs/overlay/usr/local/bin/droiddeck-steam-compat b/tools/linuxfs/overlay/usr/local/bin/droiddeck-steam-compat index f2adc5581..88f66e1eb 100755 --- a/tools/linuxfs/overlay/usr/local/bin/droiddeck-steam-compat +++ b/tools/linuxfs/overlay/usr/local/bin/droiddeck-steam-compat @@ -8,6 +8,7 @@ import select import signal import socket import struct +import subprocess import sys import time @@ -125,6 +126,37 @@ INSTALL_JS = r""" return "installed"; })() """.replace("__BINDING__", BINDING) +# Big Picture's "Switch to Desktop" asks the client's SteamOS manager, which the client has only when it +# runs as SteamOS (-steamos3, Deck mode); otherwise the request fails and the screen stays on "Switching +# to Desktop..." for good. The request is caught on its way to the client and answered as SteamOS's +# own path does, with steamos-session-select. +SWITCH_BINDING = "droiddeckSwitchToDesktop" +SWITCH_JS = r""" +(() => { + if (window.__droiddeckSwitch) return "present"; + const name = new TextEncoder().encode("SteamOSManager.SwitchToDesktop#"); + const send = WebSocket.prototype.send; + const asks = (data) => { + const bytes = data instanceof ArrayBuffer ? new Uint8Array(data) + : ArrayBuffer.isView(data) ? new Uint8Array(data.buffer, data.byteOffset, data.byteLength) : null; + if (!bytes) return false; + const end = Math.min(bytes.length, 256) - name.length; + for (let i = 8; i <= end; i++) { + let j = 0; + while (j < name.length && bytes[i + j] === name[j]) j++; + if (j === name.length) return true; + } + return false; + }; + WebSocket.prototype.send = function (data) { + if (typeof window.__BINDING__ === "function" && asks(data)) window.__BINDING__(""); + return send.call(this, data); + }; + window.__droiddeckSwitch = true; + return "installed"; +})() +""".replace("__BINDING__", SWITCH_BINDING) +SESSION_SELECT = "/usr/bin/steamos-session-select" class Closed(Exception): @@ -135,6 +167,18 @@ def say(message): print("droiddeck-steam-compat: %s" % message, flush=True) +def called(event, name): + return event.get("method") == "Runtime.bindingCalled" and event.get("params", {}).get("name") == name + + +def switch_to_desktop(): + say("Switch to Desktop: asking for the desktop") + try: + subprocess.call([SESSION_SELECT, "plasma"]) + except OSError as e: + say("Switch to Desktop failed: %s" % e) + + def connect(port, timeout=5): sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) sock.settimeout(timeout) @@ -357,9 +401,10 @@ class Watcher: class Helper: - def __init__(self, steam_root, port): + def __init__(self, steam_root, port, steamos=False): self.steam_root = steam_root self.port = port + self.steamos = steamos self.page = None self.known = set() self.installed = None @@ -374,6 +419,9 @@ class Helper: if page.evaluate("typeof SteamClient === 'object' && typeof SteamClient.WebUITransport === 'object'") is not True: raise LookupError("SteamClient is not ready") page.call("Runtime.addBinding", {"name": BINDING}) + if not self.steamos: + page.call("Runtime.addBinding", {"name": SWITCH_BINDING}) + page.evaluate(SWITCH_JS) page.compat("get(0)") except Exception: page.ws.close() @@ -422,6 +470,13 @@ class Helper: state = COMPAT["read_json"](COMPAT["state_path"]("state.json")) return isinstance(request.get("seq"), int) and request["seq"] > int(state.get("applied", 0) or 0) + def drain(self): + """The page's events; a switch to the desktop is acted on as it comes.""" + events = self.page.drain() + if any(called(e, SWITCH_BINDING) for e in events): + switch_to_desktop() + return events + def serve(self, watcher): with open(COMPAT["state_path"]("live.pid"), "w") as f: f.write("%d\n" % os.getpid()) @@ -432,15 +487,14 @@ class Helper: ready = [self.page.ws] if self.page.ws.pending() else select.select(sources, [], [], 30 if watcher.fileno() >= 0 else 2)[0] due = False if self.page.ws in ready: - due = any(e.get("method") == "Runtime.bindingCalled" and e.get("params", {}).get("name") == BINDING - for e in self.page.drain()) + due = any(called(e, BINDING) for e in self.drain()) if (watcher in ready or watcher.fileno() < 0) and watcher.changed(): due = self.installed != COMPAT["installed_apps"](self.steam_root) or self.request_waiting() if due: time.sleep(0.3) if watcher.fileno() >= 0 and select.select([watcher], [], [], 0)[0]: watcher.changed() - self.page.drain() + self.drain() self.reconcile() @@ -466,7 +520,9 @@ def main(): return 0 os.makedirs(COMPAT["COMPAT_DIR"], exist_ok=True) watcher = Watcher([COMPAT["state_path"]("request.json")] + [os.path.join(lib, "steamapps", "libraryfolders.vdf") for lib in (steam_root, COMPAT["LIBRARY"] + "-sd")]) - helper = Helper(steam_root, port) + # The client has its own SteamOS manager when started as SteamOS (droiddeck-session's Deck mode). + steamos = os.environ.get("BL_STEAMDECK") == "1" and os.environ.get("BL_STEAM_UI") != "desktop" + helper = Helper(steam_root, port, steamos) failures = 0 last = None while True: diff --git a/tools/linuxfs/overlay/usr/local/bin/steam-compatibility b/tools/linuxfs/overlay/usr/local/bin/steam-compatibility index f3eeb33b7..18dc6bb12 100755 --- a/tools/linuxfs/overlay/usr/local/bin/steam-compatibility +++ b/tools/linuxfs/overlay/usr/local/bin/steam-compatibility @@ -754,6 +754,21 @@ APPINFO_CACHE = {} STEAM_PLAY_MANIFESTS = 891390 +def launch_programs(config): + """The Windows and Linux programs an app's launch options start, relative to its folder (lowercase, "/").""" + launch = config.get("launch") if isinstance(config, dict) else None + found = [] + for option in launch.values() if isinstance(launch, dict) else (): + if not isinstance(option, dict) or not option.get("executable"): + continue + settings = option.get("config") if isinstance(option.get("config"), dict) else {} + oslist = str(settings.get("oslist", "")).lower() + if oslist and "windows" not in oslist and "linux" not in oslist: + continue + found.append(os.path.normpath(str(option["executable"]).replace("\\", "/")).lstrip("/").lower()) + return found + + def appinfo_entries(path): import struct try: @@ -844,6 +859,7 @@ def appinfo_entries(path): "osarch": str(common.get("osarch", "")).lower(), "type": str(common.get("type", "")).lower(), "recommended": str(recommended), + "launch": launch_programs(info.get("config")), } if app == STEAM_PLAY_MANIFESTS: extended = info.get("extended", {}) diff --git a/tools/linuxfs/preload/binfmt.c b/tools/linuxfs/preload/binfmt.c new file mode 100644 index 000000000..6592a8d5e --- /dev/null +++ b/tools/linuxfs/preload/binfmt.c @@ -0,0 +1,206 @@ +/* + * binfmt_misc for the desktop, which proot does not have: an exec of an x86 Linux program, a Windows + * program, or a program or script on noexec shared storage goes to droiddeck-open --exec, which runs + * it under FEX, Proton or its interpreter. x86 and Windows programs are caught before the exec: proot + * loads a static x86 program as a native one, which dies on its first instruction, and execvp runs a + * Windows program as a shell script. A program on noexec storage also passes access(X_OK), which KIO + * and Qt ask before they start one. Only in the desktop session. + */ +#define _GNU_SOURCE +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#ifndef BINFMT_HANDLER +#define BINFMT_HANDLER "/usr/local/bin/droiddeck-open" +#endif + +typedef int (*spawn_fn)(pid_t *, const char *, const posix_spawn_file_actions_t *, const posix_spawnattr_t *, + char *const[], char *const[]); + +/* BINFMT_TEST: tools/tests builds it for the host, whose own x86 programs stand in for foreign ones. */ +#if defined(__aarch64__) || defined(BINFMT_TEST) + +static int desktop(void) { + const char *value = getenv("BL_DESKTOP"); + return value && value[0] == '1' && value[1] == 0; +} + +/* 1: x86 program or noexec storage, 2: Windows program, 3: script; 0 for anything else. */ +static int foreign(const char *path, int error) { + if (!path || !strcmp(path, BINFMT_HANDLER)) return 0; + int fd = open(path, O_RDONLY | O_CLOEXEC); + if (fd < 0) return 0; + struct stat st; + unsigned char head[20]; + ssize_t n = fstat(fd, &st) == 0 && S_ISREG(st.st_mode) ? read(fd, head, sizeof head) : -1; + int kind = 0; + if (n >= 20 && !memcmp(head, ELFMAG, SELFMAG)) { + unsigned machine = head[EI_DATA] == ELFDATA2MSB ? (unsigned)head[18] << 8 | head[19] : head[18] | (unsigned)head[19] << 8; + kind = machine == EM_X86_64 || machine == EM_386 || error == EACCES ? 1 : 0; + } else if (n >= 2 && head[0] == 'M' && head[1] == 'Z') { + kind = 2; + } else if (n >= 2 && head[0] == '#' && head[1] == '!' && error == EACCES) { + kind = 3; + } + /* What the kernel refuses for its permissions stays refused; noexec storage has no execute bits to give. */ + struct statvfs vfs; + int allowed = kind && (((st.st_mode & 0111) && error != EACCES) || (fstatvfs(fd, &vfs) == 0 && (vfs.f_flag & ST_NOEXEC))); + close(fd); + return allowed ? kind : 0; +} + +static int wanted(const char *path, int error) { + return (error == ENOEXEC || error == ENOENT || error == EACCES) && desktop() && foreign(path, error); +} + +/* The program on PATH as execvp would find it, into [out]. */ +static int lookup(const char *file, char *out, size_t size) { + if (!file || !*file) return 0; + if (strchr(file, '/')) return snprintf(out, size, "%s", file) < (int)size; + const char *paths = getenv("PATH"); + if (!paths) paths = "/bin:/usr/bin"; + for (const char *p = paths;; ) { + const char *end = strchrnul(p, ':'); + int n = end > p ? snprintf(out, size, "%.*s/%s", (int)(end - p), p, file) : snprintf(out, size, "%s", file); + struct stat st; + if (n > 0 && n < (int)size && stat(out, &st) == 0 && S_ISREG(st.st_mode)) return 1; + if (!*end) return 0; + p = end + 1; + } +} + +static int count(char *const argv[]) { + int n = 0; + while (argv && argv[n]) n++; + return n; +} + +static void handler_args(char **args, const char *path, char *const argv[], int n) { + args[0] = "droiddeck-open"; + args[1] = "--exec"; + args[2] = (char *)path; + int i = 3; + for (int k = 1; k < n; k++) args[i++] = argv[k]; + args[i] = NULL; +} + +static void hand_off(const char *path, char *const argv[], char *const envp[]) { + static int (*real)(const char *, char *const[], char *const[]); + if (!real) real = (int (*)(const char *, char *const[], char *const[]))dlsym(RTLD_NEXT, "execve"); + int n = count(argv); + char *args[n + 4]; + handler_args(args, path, argv, n); + real(BINFMT_HANDLER, args, envp); +} + +static int spawn_handler(pid_t *pid, const char *path, const posix_spawn_file_actions_t *fa, const posix_spawnattr_t *attr, + char *const argv[], char *const envp[], spawn_fn real) { + int n = count(argv); + char *args[n + 4]; + handler_args(args, path, argv, n); + return real(pid, BINFMT_HANDLER, fa, attr, args, envp); +} + +/* Before an exec of [path]: an x86 or Windows program goes to the handler instead. */ +__attribute__((visibility("hidden"))) void bl_binfmt_before(const char *path, char *const argv[], char *const envp[]) { + if (desktop() && foreign(path, ENOEXEC)) hand_off(path, argv, envp); +} + +/* After a failed exec of [path]: the handler takes it over, or the exec's own error stands. */ +__attribute__((visibility("hidden"))) int bl_binfmt_retry(const char *path, char *const argv[], char *const envp[], int error) { + if (wanted(path, error)) hand_off(path, argv, envp); + errno = error; + return -1; +} + +/* The same around execvp, for the program it finds on PATH. */ +__attribute__((visibility("hidden"))) void bl_binfmt_before_search(const char *file, char *const argv[], char *const envp[]) { + char path[PATH_MAX]; + if (desktop() && lookup(file, path, sizeof path)) bl_binfmt_before(path, argv, envp); +} + +__attribute__((visibility("hidden"))) int bl_binfmt_after_search(const char *file, char *const argv[], char *const envp[], int error) { + char path[PATH_MAX]; + if (desktop() && lookup(file, path, sizeof path)) return bl_binfmt_retry(path, argv, envp, error); + errno = error; + return -1; +} + +/* After access(X_OK) of [path] was refused (pathcache.c): a program on noexec storage runs all the same. */ +__attribute__((visibility("hidden"))) int bl_binfmt_runnable(const char *path, int mode) { + if (mode != X_OK || !desktop()) return 0; + int runs = foreign(path, EACCES) != 0; + errno = EACCES; + return runs; +} + +__attribute__((visibility("hidden"))) int bl_binfmt_spawn(pid_t *pid, const char *path, const posix_spawn_file_actions_t *fa, + const posix_spawnattr_t *attr, char *const argv[], char *const envp[], + spawn_fn real) { + if (desktop() && foreign(path, ENOEXEC)) return spawn_handler(pid, path, fa, attr, argv, envp, real); + int error = real(pid, path, fa, attr, argv, envp); + return error && wanted(path, error) ? spawn_handler(pid, path, fa, attr, argv, envp, real) : error; +} + +int execvpe(const char *file, char *const argv[], char *const envp[]) { + static int (*real)(const char *, char *const[], char *const[]); + if (!real) real = (int (*)(const char *, char *const[], char *const[]))dlsym(RTLD_NEXT, "execvpe"); + bl_binfmt_before_search(file, argv, envp); + real(file, argv, envp); + return bl_binfmt_after_search(file, argv, envp, errno); +} + +int posix_spawnp(pid_t *pid, const char *file, const posix_spawn_file_actions_t *fa, const posix_spawnattr_t *attr, + char *const argv[], char *const envp[]) { + static spawn_fn real, spawn; + if (!real) real = (spawn_fn)dlsym(RTLD_NEXT, "posix_spawnp"); + if (!spawn) spawn = (spawn_fn)dlsym(RTLD_NEXT, "posix_spawn"); + char path[PATH_MAX]; + if (!desktop() || !lookup(file, path, sizeof path)) return real(pid, file, fa, attr, argv, envp); + return bl_binfmt_spawn(pid, path, fa, attr, argv, envp, spawn); +} + +#else + +__attribute__((visibility("hidden"))) int bl_binfmt_runnable(const char *path, int mode) { + (void)path, (void)mode; + return 0; +} + +__attribute__((visibility("hidden"))) void bl_binfmt_before(const char *path, char *const argv[], char *const envp[]) { + (void)path, (void)argv, (void)envp; +} + +__attribute__((visibility("hidden"))) int bl_binfmt_retry(const char *path, char *const argv[], char *const envp[], int error) { + (void)path, (void)argv, (void)envp; + errno = error; + return -1; +} + +__attribute__((visibility("hidden"))) void bl_binfmt_before_search(const char *file, char *const argv[], char *const envp[]) { + (void)file, (void)argv, (void)envp; +} + +__attribute__((visibility("hidden"))) int bl_binfmt_after_search(const char *file, char *const argv[], char *const envp[], int error) { + (void)file, (void)argv, (void)envp; + errno = error; + return -1; +} + +__attribute__((visibility("hidden"))) int bl_binfmt_spawn(pid_t *pid, const char *path, const posix_spawn_file_actions_t *fa, + const posix_spawnattr_t *attr, char *const argv[], char *const envp[], + spawn_fn real) { + return real(pid, path, fa, attr, argv, envp); +} + +#endif diff --git a/tools/linuxfs/preload/fsync.c b/tools/linuxfs/preload/fsync.c index 4d765d905..844af92b8 100644 --- a/tools/linuxfs/preload/fsync.c +++ b/tools/linuxfs/preload/fsync.c @@ -101,6 +101,7 @@ static int (*fs_real_shm_unlink)(const char *); static void *(*fs_real_mmap)(void *, size_t, int, int, int, off_t); static void *(*fs_real_mmap64)(void *, size_t, int, int, int, off64_t); static int (*fs_real_munmap)(void *, size_t); +__attribute__((visibility("hidden"))) int bl_noexec_retry(int prot, int flags, int fd); static int fs_on(void) { if (fs_state < 0) { @@ -623,6 +624,7 @@ void *mmap(void *addr, size_t len, int prot, int flags, int fd, off_t off) { void *p; if (!fs_real_mmap) fs_real_mmap = (void *(*)(void *, size_t, int, int, int, off_t))dlsym(RTLD_NEXT, "mmap"); p = fs_real_mmap(addr, len, prot, flags, fd, off); + if (p == MAP_FAILED && bl_noexec_retry(prot, flags, fd)) p = fs_real_mmap(addr, len, prot & ~PROT_EXEC, flags, fd, off); if (p != MAP_FAILED && __builtin_expect(fs_fd >= 0, 0)) fs_track(p, len, flags, fd, off); return p; } @@ -631,6 +633,7 @@ void *mmap64(void *addr, size_t len, int prot, int flags, int fd, off64_t off) { void *p; if (!fs_real_mmap64) fs_real_mmap64 = (void *(*)(void *, size_t, int, int, int, off64_t))dlsym(RTLD_NEXT, "mmap64"); p = fs_real_mmap64(addr, len, prot, flags, fd, off); + if (p == MAP_FAILED && bl_noexec_retry(prot, flags, fd)) p = fs_real_mmap64(addr, len, prot & ~PROT_EXEC, flags, fd, off); if (p != MAP_FAILED && __builtin_expect(fs_fd >= 0, 0)) fs_track(p, len, flags, fd, off); return p; } diff --git a/tools/linuxfs/preload/net.c b/tools/linuxfs/preload/net.c index c06c8dd79..636ba1aea 100644 --- a/tools/linuxfs/preload/net.c +++ b/tools/linuxfs/preload/net.c @@ -267,6 +267,18 @@ int accept(int fd, struct sockaddr *addr, socklen_t *len) { return accept4(fd, addr, len, 0); } +/* binfmt.c: an exec of a program the kernel cannot run, handed to droiddeck-open in the desktop. */ +extern char **environ; +typedef int (*spawn_fn)(pid_t *, const char *, const posix_spawn_file_actions_t *, const posix_spawnattr_t *, + char *const[], char *const[]); +__attribute__((visibility("hidden"))) void bl_binfmt_before(const char *path, char *const argv[], char *const envp[]); +__attribute__((visibility("hidden"))) int bl_binfmt_retry(const char *path, char *const argv[], char *const envp[], int error); +__attribute__((visibility("hidden"))) void bl_binfmt_before_search(const char *file, char *const argv[], char *const envp[]); +__attribute__((visibility("hidden"))) int bl_binfmt_after_search(const char *file, char *const argv[], char *const envp[], int error); +__attribute__((visibility("hidden"))) int bl_binfmt_spawn(pid_t *pid, const char *path, const posix_spawn_file_actions_t *fa, + const posix_spawnattr_t *attr, char *const argv[], char *const envp[], + spawn_fn real); + /* lsof would read the denied /proc/net/tcp; answer its -i TCP@host:port query from the registry * instead of executing it. Recognised only when invoked as lsof with that query. */ static int maybe_answer_lsof(const char *path, char *const argv[]) { @@ -317,7 +329,9 @@ int execve(const char *path, char *const argv[], char *const envp[]) { static int (*real)(const char *, char *const[], char *const[]); if (!real) real = (int (*)(const char *, char *const[], char *const[]))dlsym(RTLD_NEXT, "execve"); maybe_answer_lsof(path, argv); - return real(path, argv, envp); + bl_binfmt_before(path, argv, envp); + real(path, argv, envp); + return bl_binfmt_retry(path, argv, envp, errno); } /* popen(3) and posix_spawn(3) reach lsof without going through the execve symbol above. The @@ -341,14 +355,18 @@ int execvp(const char *file, char *const argv[]) { static int (*real)(const char *, char *const[]); if (!real) real = (int (*)(const char *, char *const[]))dlsym(RTLD_NEXT, "execvp"); maybe_answer_lsof(file, argv); - return real(file, argv); + bl_binfmt_before_search(file, argv, environ); + real(file, argv); + return bl_binfmt_after_search(file, argv, environ, errno); } int execv(const char *path, char *const argv[]) { static int (*real)(const char *, char *const[]); if (!real) real = (int (*)(const char *, char *const[]))dlsym(RTLD_NEXT, "execv"); maybe_answer_lsof(path, argv); - return real(path, argv); + bl_binfmt_before(path, argv, environ); + real(path, argv); + return bl_binfmt_retry(path, argv, environ, errno); } int posix_spawn(pid_t *pid, const char *path, const posix_spawn_file_actions_t *fa, @@ -358,9 +376,7 @@ int posix_spawn(pid_t *pid, const char *path, const posix_spawn_file_actions_t * if (strcmp(base, "lsof") == 0 && !fa) { return answer_lsof_via_spawn(path, argv, pid); } - static int (*real)(pid_t *, const char *, const posix_spawn_file_actions_t *, - const posix_spawnattr_t *, char *const[], char *const[]); - if (!real) real = (int (*)(pid_t *, const char *, const posix_spawn_file_actions_t *, - const posix_spawnattr_t *, char *const[], char *const[]))dlsym(RTLD_NEXT, "posix_spawn"); - return real(pid, path, fa, attr, argv, envp); + static spawn_fn real; + if (!real) real = (spawn_fn)dlsym(RTLD_NEXT, "posix_spawn"); + return bl_binfmt_spawn(pid, path, fa, attr, argv, envp, real); } diff --git a/tools/linuxfs/preload/noexec.c b/tools/linuxfs/preload/noexec.c new file mode 100644 index 000000000..26aa539b7 --- /dev/null +++ b/tools/linuxfs/preload/noexec.c @@ -0,0 +1,65 @@ +/* + * noexec.c: FEX runs an x86 program and its libraries where they lie, on noexec shared storage too. + * FEX maps them with the guest's PROT_EXEC, which the kernel refuses for a file on a noexec mount, + * but it never runs those pages itself - it runs its own translation of them - so a mapping or an + * mprotect refused for that alone is made without PROT_EXEC. Only in FEX's own processes. + */ +#define _GNU_SOURCE +#include +#include +#include +#include +#include +#include + +/* NOEXEC_TEST: tools/tests builds it for the host. */ +#if defined(__aarch64__) || defined(NOEXEC_TEST) + +static int in_fex(void) { + static int known = -1; + if (known < 0) { + char exe[512]; + ssize_t n = readlink("/proc/self/exe", exe, sizeof exe - 1); + exe[n > 0 ? n : 0] = 0; + const char *name = strrchr(exe, '/'); + name = name ? name + 1 : exe; + known = !strcmp(name, "FEX") || !strcmp(name, "FEXInterpreter") || !strcmp(name, "FEXLoader"); + } + return known; +} + +/* After an mmap failed (fsync.c's mmap asks): whether to map it again without PROT_EXEC. */ +__attribute__((visibility("hidden"))) int bl_noexec_retry(int prot, int flags, int fd) { + int error = errno; + struct statvfs vfs; + int retry = (error == EACCES || error == EPERM) && (prot & PROT_EXEC) && fd >= 0 && !(flags & MAP_ANONYMOUS) && + in_fex() && fstatvfs(fd, &vfs) == 0 && (vfs.f_flag & ST_NOEXEC); + errno = error; + return retry; +} + +static int (*real_mprotect)(void *, size_t, int); + +/* Looked up before anything runs: Wine calls mprotect from its signal handlers, where dlsym is unsafe. */ +__attribute__((constructor)) static void noexec_init(void) { + real_mprotect = (int (*)(void *, size_t, int))dlsym(RTLD_NEXT, "mprotect"); +} + +int mprotect(void *addr, size_t len, int prot) { + if (!real_mprotect) noexec_init(); + int result = real_mprotect(addr, len, prot); + if (result && errno == EACCES && (prot & PROT_EXEC) && in_fex()) { + result = real_mprotect(addr, len, prot & ~PROT_EXEC); + if (result) errno = EACCES; + } + return result; +} + +#else + +__attribute__((visibility("hidden"))) int bl_noexec_retry(int prot, int flags, int fd) { + (void)prot, (void)flags, (void)fd; + return 0; +} + +#endif diff --git a/tools/linuxfs/preload/pathcache.c b/tools/linuxfs/preload/pathcache.c index 2f2cfd3d4..0aab91bd7 100644 --- a/tools/linuxfs/preload/pathcache.c +++ b/tools/linuxfs/preload/pathcache.c @@ -152,14 +152,19 @@ static int (*next_faccessat(void))(int, const char *, int, int) { return real; } +/* binfmt.c: a program on noexec storage, which the desktop runs all the same. */ +__attribute__((visibility("hidden"))) int bl_binfmt_runnable(const char *path, int mode); + static int check_cwd(const char *path, int mode, int flags) { int (*real)(int, const char *, int, int) = next_faccessat(); + int result; if (real == NULL) { errno = ENOSYS; return -1; } - return real(AT_FDCWD, path, mode, flags); + result = real(AT_FDCWD, path, mode, flags); + return result != 0 && errno == EACCES && bl_binfmt_runnable(path, mode) ? 0 : result; } int access(const char *path, int mode) { diff --git a/tools/tests/test_binfmt_preload.py b/tools/tests/test_binfmt_preload.py new file mode 100644 index 000000000..b1b0c0940 --- /dev/null +++ b/tools/tests/test_binfmt_preload.py @@ -0,0 +1,160 @@ +import errno +import os +from pathlib import Path +import shutil +import subprocess +import tempfile +import unittest + +PRELOAD = Path(__file__).resolve().parents[1] / "linuxfs/preload" + +PROGRAM = r""" +#define _GNU_SOURCE +#include +#include +#include +#include +#include +#include + +extern char **environ; + +int main(int argc, char **argv) { + if (argc < 3) return 2; + const char *how = argv[1], *file = argv[2]; + char **args = argv + 2; + if (!strcmp(how, "access")) { + int result = access(file, X_OK); + printf("access %d %d\n", result, result ? errno : 0); + return 0; + } + if (!strcmp(how, "spawn") || !strcmp(how, "spawnp")) { + pid_t pid; + int error = how[5] ? posix_spawnp(&pid, file, NULL, NULL, args, environ) : posix_spawn(&pid, file, NULL, NULL, args, environ); + if (error) { printf("errno %d\n", error); return 3; } + int status; + waitpid(pid, &status, 0); + printf("exit %d\n", WEXITSTATUS(status)); + return 0; + } + if (!strcmp(how, "execve")) execve(file, args, environ); + else if (!strcmp(how, "execv")) execv(file, args); + else if (!strcmp(how, "execvp")) execvp(file, args); + else if (!strcmp(how, "execvpe")) execvpe(file, args, environ); + printf("errno %d\n", errno); + return 3; +} +""" + +# Shell builtins only: anything it ran would be an x86 program, handed back to it. +HANDLER = "#!/bin/sh\nprintf '%s\\n' \"$@\" > \"$HANDLER_LOG\"\nexit 7\n" + + +@unittest.skipUnless(shutil.which("gcc") and os.uname().machine == "x86_64", "needs gcc on an x86-64 host") +class BinfmtPreloadTest(unittest.TestCase): + @classmethod + def setUpClass(cls): + cls.tmp = Path(tempfile.mkdtemp()) + cls.handler = cls.tmp / "handler" + cls.handler.write_text(HANDLER) + cls.handler.chmod(0o755) + cls.library = cls.tmp / "libbinfmt.so" + subprocess.run(["gcc", "-shared", "-fPIC", "-O2", "-Wall", "-Wextra", "-Werror", "-DBINFMT_TEST", + '-DBINFMT_HANDLER="%s"' % cls.handler, "-o", str(cls.library), + "-pthread"] + [str(PRELOAD / name) for name in ("binfmt.c", "net.c", "udevmon.c", "pathcache.c")] + ["-ldl"], + check=True) + source = cls.tmp / "program.c" + source.write_text(PROGRAM) + cls.program = cls.tmp / "program" + subprocess.run(["gcc", "-O2", "-o", str(cls.program), str(source)], check=True) + + @classmethod + def tearDownClass(cls): + shutil.rmtree(cls.tmp, True) + + def setUp(self): + self.dir = Path(tempfile.mkdtemp(dir=self.tmp)) + self.log = self.dir / "handler.log" + + def file(self, name, data, mode=0o755): + path = self.dir / name + path.write_bytes(data) + path.chmod(mode) + return path + + def x86(self, name="tool", mode=0o755): + path = self.dir / name + shutil.copyfile(shutil.which("true"), path) + path.chmod(mode) + return path + + def run_program(self, how, target, *args, desktop=True): + env = {"PATH": "%s:/usr/bin:/bin" % self.dir, "LD_PRELOAD": str(self.library), "HANDLER_LOG": str(self.log)} + if desktop: + env["BL_DESKTOP"] = "1" + done = subprocess.run([str(self.program), how, str(target)] + list(args), env=env, + stdout=subprocess.PIPE, text=True, timeout=30) + handed = self.log.read_text().splitlines() if self.log.exists() else None + return done.returncode, done.stdout.strip(), handed + + def test_an_x86_program_goes_to_the_handler_before_it_is_executed(self): + tool = self.x86() + for how in ("execve", "execv"): + self.log.unlink(missing_ok=True) + self.assertEqual(self.run_program(how, tool, "a", "b c"), (7, "", ["--exec", str(tool), "a", "b c"])) + + def test_outside_the_desktop_nothing_changes(self): + self.assertEqual(self.run_program("execve", self.x86(), desktop=False), (0, "", None)) + + def test_a_program_without_execute_permission_stays_refused(self): + tool = self.x86(mode=0o644) + self.assertEqual(self.run_program("execve", tool), (3, "errno %d" % errno.EACCES, None)) + + def test_a_native_program_the_kernel_cannot_run_keeps_its_error(self): + arm64 = bytearray(64) + arm64[0:4], arm64[4], arm64[5], arm64[18] = b"\x7fELF", 2, 1, 183 + program = self.file("arm64", bytes(arm64)) + self.assertEqual(self.run_program("execve", program), (3, "errno %d" % errno.ENOEXEC, None)) + + def test_a_script_runs_as_itself(self): + script = self.file("script.sh", b"#!/bin/sh\nexit 5\n") + self.assertEqual(self.run_program("execve", script), (5, "", None)) + + def test_a_windows_program_found_on_path_goes_to_the_handler(self): + program = self.file("setup.exe", b"MZ" + bytes(62)) + for how in ("execvp", "execvpe"): + self.log.unlink(missing_ok=True) + self.assertEqual(self.run_program(how, "setup.exe", "/S"), (7, "", ["--exec", str(program), "/S"])) + + def test_a_spawned_x86_program_goes_to_the_handler(self): + tool = self.x86() + self.assertEqual(self.run_program("spawn", tool, "x"), (0, "exit 7", ["--exec", str(tool), "x"])) + self.log.unlink() + self.assertEqual(self.run_program("spawnp", "tool", "y"), (0, "exit 7", ["--exec", str(tool), "y"])) + + def test_access_keeps_the_kernels_answer_off_noexec_storage(self): + self.assertEqual(self.run_program("access", self.x86(mode=0o644)), (0, "access -1 %d" % errno.EACCES, None)) + self.assertEqual(self.run_program("access", self.x86()), (0, "access 0 0", None)) + + def test_a_program_on_noexec_storage_passes_access(self): + storage = next((d for d in (os.environ.get("XDG_RUNTIME_DIR"), "/dev/shm", "/run/user/%d" % os.getuid()) + if d and os.path.isdir(d) and os.access(d, os.W_OK) and os.statvfs(d).f_flag & os.ST_NOEXEC), None) + if storage is None: + self.skipTest("no writable noexec mount here") + folder = Path(tempfile.mkdtemp(dir=storage)) + self.addCleanup(shutil.rmtree, folder, True) + tool = folder / "tool" + shutil.copyfile(shutil.which("true"), tool) + notes = folder / "notes.txt" + notes.write_text("hello\n") + self.assertEqual(self.run_program("access", tool), (0, "access 0 0", None)) + self.assertEqual(self.run_program("access", notes), (0, "access -1 %d" % errno.EACCES, None)) + self.assertEqual(self.run_program("access", tool, desktop=False), (0, "access -1 %d" % errno.EACCES, None)) + + def test_a_spawned_native_script_is_left_alone(self): + self.file("script.sh", b"#!/bin/sh\nexit 5\n") + self.assertEqual(self.run_program("spawnp", "script.sh"), (0, "exit 5", None)) + + +if __name__ == "__main__": + unittest.main() diff --git a/tools/tests/test_cdp_guard.py b/tools/tests/test_cdp_guard.py index 98e586f12..7dec3560c 100644 --- a/tools/tests/test_cdp_guard.py +++ b/tools/tests/test_cdp_guard.py @@ -16,7 +16,8 @@ class CdpGuardTest(unittest.TestCase): def setUpClass(cls): cls.build = tempfile.TemporaryDirectory() cls.library = Path(cls.build.name) / "net.so" - subprocess.run(["cc", "-shared", "-fPIC", "-O2", str(SOURCE), "-x", "c", "-", "-ldl", "-o", str(cls.library)], + subprocess.run(["cc", "-shared", "-fPIC", "-O2", str(SOURCE), str(SOURCE.parent / "binfmt.c"), "-x", "c", "-", "-ldl", + "-o", str(cls.library)], input=b"int bl_udevmon_stand_in(int fd) { return 0; }", check=True, capture_output=True) @classmethod diff --git a/tools/tests/test_desktop_open.py b/tools/tests/test_desktop_open.py new file mode 100644 index 000000000..a766a2467 --- /dev/null +++ b/tools/tests/test_desktop_open.py @@ -0,0 +1,521 @@ +import contextlib +import os +from pathlib import Path +import runpy +import shutil +import struct +import tempfile +import threading +import time +import unittest +from unittest import mock +import zlib + +BIN = Path(__file__).resolve().parents[1] / "linuxfs/overlay/usr/local/bin" +OPEN = runpy.run_path(str(BIN / "droiddeck-open"))["main"].__globals__ +RUN = runpy.run_path(str(BIN / "droiddeck-proton-run"))["main"].__globals__ + + +def elf(machine, extra=b""): + head = bytearray(64) + head[0:4], head[4], head[5], head[18] = b"\x7fELF", 2, 1, machine + head[8:8 + len(extra)] = extra + return bytes(head) + + +class Temp(unittest.TestCase): + def setUp(self): + self.tmp = Path(tempfile.mkdtemp()) + self.addCleanup(shutil.rmtree, self.tmp, True) + + def write(self, relative, data, mode=0o644): + path = self.tmp / relative + path.parent.mkdir(parents=True, exist_ok=True) + path.write_bytes(data if isinstance(data, bytes) else data.encode()) + path.chmod(mode) + return path + + +class KindTest(Temp): + def test_each_file_is_told_by_its_content_then_its_name(self): + cases = { + "game.x86_64": (elf(62), "elf"), + "Tool.AppImage": (elf(183, b"AI\x02"), "appimage"), + "renamed": (elf(62, b"AI\x02"), "appimage"), + "setup.exe": (b"MZ" + bytes(62), "windows"), + "launcher.bat": (b"@echo off\r\n", "windows"), + "no-extension": (b"MZ" + bytes(62), "windows"), + "d3d11.dll": (b"MZ" + bytes(62), None), + "start.sh": (b"echo hi\n", "script"), + "run": (b"#!/usr/bin/env python3\n", "script"), + "notes.txt": (b"hello\n", None), + } + for name, (data, expected) in cases.items(): + with self.subTest(name): + self.assertEqual(OPEN["kind"](str(self.write(name, data))), expected) + + def test_a_script_names_its_interpreter_or_gets_bash(self): + self.assertEqual(OPEN["interpreter"](str(self.write("a", b"#!/usr/bin/env python3 -u\r\nx\n"))), + ["/usr/bin/env", "python3", "-u"]) + self.assertEqual(OPEN["interpreter"](str(self.write("b", b"echo\n"))), ["/bin/bash"]) + + +class PlacementTest(Temp): + def setUp(self): + super().setUp() + self.gpu = self.write("droiddeck-gpu", b"#!/bin/sh\n", 0o755) + patcher = mock.patch.dict(OPEN, {"GPU": str(self.gpu), "unattended": lambda env: False}) + patcher.start() + self.addCleanup(patcher.stop) + self.desktop = {"BL_DESKTOP": "1"} + + def placed(self, what, mode, env=None): + return OPEN["placed"](["cmd"], what, mode, self.desktop if env is None else env) + + def test_programs_from_the_desktop_go_to_the_gpu(self): + for what in ("windows", "elf", "appimage", "x86 script", "folder"): + with self.subTest(what): + self.assertEqual(self.placed(what, "run"), [str(self.gpu), "cmd"]) + + def test_a_plain_script_and_a_window_stay_on_the_desktop(self): + self.assertEqual(self.placed("script", "run"), ["cmd"]) + self.assertEqual(self.placed("windows", "window"), ["cmd"]) + + def test_away_from_the_desktop_nothing_moves(self): + self.assertEqual(self.placed("windows", "run", {}), ["cmd"]) + self.assertEqual(self.placed("windows", "run", dict(self.desktop, GAMESCOPE_WAYLAND_DISPLAY="x")), ["cmd"]) + + def test_konsole_takes_what_asks_for_a_terminal(self): + with mock.patch.object(OPEN["shutil"], "which", return_value="/usr/bin/konsole"): + self.assertEqual(self.placed("script", "terminal"), ["konsole", "--hold", "-e", "cmd"]) + self.assertEqual(self.placed("windows", "terminal"), [str(self.gpu), "cmd"]) + + def test_an_exec_stays_where_its_output_is_read(self): + self.assertEqual(self.placed("elf", "exec"), ["cmd"]) + self.assertEqual(self.placed("windows", "exec"), [str(self.gpu), "cmd"]) + with mock.patch.dict(OPEN, {"unattended": lambda env: True}): + self.assertEqual(self.placed("elf", "exec"), [str(self.gpu), "cmd"]) + + +class UnattendedTest(Temp): + def with_stdout(self, path, env): + saved = os.dup(1) + try: + with open(path, "w") as target: + os.dup2(target.fileno(), 1) + return OPEN["unattended"](env) + finally: + os.dup2(saved, 1) + os.close(saved) + + def test_only_output_nobody_reads_counts(self): + log = self.write("session/desktop.log", b"") + env = {"BL_DEBUG_DIR": str(log.parent)} + self.assertTrue(self.with_stdout(os.devnull, env)) + self.assertTrue(self.with_stdout(str(log), env)) + self.assertFalse(self.with_stdout(str(self.tmp / "out.txt"), env)) + self.assertFalse(self.with_stdout(str(log), {})) + read, write = os.pipe() + saved = os.dup(1) + try: + os.dup2(write, 1) + self.assertFalse(OPEN["unattended"](env)) + finally: + os.dup2(saved, 1) + for fd in (saved, read, write): + os.close(fd) + + +class CommandTest(Temp): + def test_each_kind_gets_its_runner(self): + exe, script = str(self.tmp / "a.exe"), str(self.tmp / "go.sh") + self.write("go.sh", b"#!/bin/sh\n") + self.assertEqual(OPEN["command"](exe, ["-x"], "windows"), ([OPEN["PROTON_RUN"], exe, "-x"], str(self.tmp))) + self.assertEqual(OPEN["command"](exe, [], "windows", True)[0], [OPEN["PROTON_RUN"], "--window", exe]) + self.assertEqual(OPEN["command"](script, ["1"], "script")[0], ["/bin/sh", script, "1"]) + self.assertEqual(OPEN["command"](script, [], "x86 script")[0], + [OPEN["FEX"], "run", "--mode", "on", "--for", str(self.tmp), "--", "/bin/sh", script]) + + def test_a_native_program_on_noexec_storage_runs_from_a_copy(self): + program = self.write("storage/tool", elf(183)) + x86 = self.write("storage/game.x86_64", elf(62)) + with mock.patch.dict(OPEN, {"CACHE": str(self.tmp / "cache"), "noexec": lambda path: True}): + copy = OPEN["runnable"](str(program)) + self.assertNotEqual(copy, str(program)) + self.assertEqual(Path(copy).read_bytes(), elf(183)) + self.assertTrue(os.access(copy, os.X_OK)) + self.assertEqual(OPEN["runnable"](str(program)), copy) + self.assertEqual(OPEN["runnable"](str(x86)), str(x86)) + with mock.patch.dict(OPEN, {"noexec": lambda path: False}): + self.assertEqual(OPEN["runnable"](str(program)), str(program)) + + +class InstallTest(Temp): + def test_the_run_entries_and_defaults_are_written_once(self): + OPEN["install"](str(self.tmp)) + entry = (self.tmp / "droiddeck-open.desktop").read_text() + self.assertIn("Exec=/usr/local/bin/droiddeck-open %f", entry) + self.assertIn("application/x-ms-dos-executable", entry) + self.assertIn("Exec=/usr/local/bin/droiddeck-open --terminal %f", + (self.tmp / "droiddeck-open-terminal.desktop").read_text()) + defaults = (self.tmp / "mimeapps.list").read_text() + self.assertIn("application/x-shellscript=droiddeck-open.desktop\n", defaults) + self.assertIn("application/x-msi=droiddeck-open.desktop;droiddeck-open-window.desktop;\n", defaults) + stamp = (self.tmp / "mimeapps.list").stat().st_mtime_ns + time.sleep(0.01) + OPEN["install"](str(self.tmp)) + self.assertEqual((self.tmp / "mimeapps.list").stat().st_mtime_ns, stamp) + + +class ImportTest(Temp): + def test_the_app_unpacks_what_the_desktop_cannot(self): + launch = self.tmp / "launch" + launch.mkdir() + folder = self.tmp / "imported/eden" + (folder / "app").mkdir(parents=True) + + def app(): + request = launch / "desktop-import-0123456789abcdef.request" + while not request.exists(): + time.sleep(0.05) + text = request.read_text() + request.unlink() + self.assertEqual(text, "id=0123456789abcdef\nkind=appimage\npath=/root/Storage/Eden.AppImage\n") + (launch / "desktop-import-0123456789abcdef.result").write_text("ok %s\n" % folder) + + worker = threading.Thread(target=app) + worker.start() + with mock.patch.dict(os.environ, {"BL_LAUNCH_DIR": str(launch)}), mock.patch.dict(OPEN, {"notify": lambda *a: None}): + self.assertEqual(OPEN["imported"]("appimage", "/root/Storage/Eden.AppImage", "0123456789abcdef", "Eden"), str(folder)) + worker.join() + self.assertEqual(list(launch.iterdir()), []) + + def test_the_apps_answer_is_the_error(self): + launch = self.tmp / "launch" + launch.mkdir() + (launch / "desktop-import-0123456789abcdef.result").write_text("error Not enough space\n") + with mock.patch.dict(os.environ, {"BL_LAUNCH_DIR": str(launch)}), mock.patch.dict(OPEN, {"notify": lambda *a: None}): + with self.assertRaisesRegex(RuntimeError, "^Not enough space$"): + OPEN["imported"]("appimage", "/x.AppImage", "0123456789abcdef", "x") + + def test_outside_a_session_it_says_how_to_add_one(self): + with mock.patch.dict(os.environ, {"BL_LAUNCH_DIR": ""}): + with self.assertRaisesRegex(RuntimeError, "Add an app"): + OPEN["imported"]("folder", "/x/start.sh", "0123456789abcdef", "x") + + def test_starts_of_one_image_unpack_it_once(self): + image = self.write("Tool.AppImage", elf(183, b"AI\x02")) + unpacks = [] + + def extract(cmd, cwd, stdout): + unpacks.append(cwd) + time.sleep(0.2) + os.makedirs(os.path.join(cwd, "squashfs-root")) + open(os.path.join(cwd, "squashfs-root", "AppRun"), "w").close() + return 0 + + found = [] + none = {what: (str(self.tmp / "none"), made) for what, (_, made) in OPEN["IMPORTS"].items()} + with mock.patch.dict(OPEN, {"CACHE": str(self.tmp / "cache"), "IMPORTS": none, "notify": lambda *a: None}), \ + mock.patch.object(OPEN["subprocess"], "call", extract): + starts = [threading.Thread(target=lambda: found.append(OPEN["appimage"](str(image)))) for _ in range(3)] + for start in starts: + start.start() + for start in starts: + start.join() + self.assertEqual(len(unpacks), 1) + self.assertEqual(len(set(found)), 1) + self.assertTrue(os.path.isfile(os.path.join(found[0], "app", "AppRun"))) + self.assertEqual(Path(found[0], "arch").read_text(), "arm64\n") + + def test_an_earlier_import_is_found_by_its_key(self): + self.write("user/eden/desktop-import", "0123456789abcdef\n/root/Storage/Eden.AppImage") + (self.tmp / "user/eden/app").mkdir() + self.write("user/other/desktop-import", "fedcba9876543210\n/root/Storage/Other.AppImage") + self.write("apps/game/desktop-import", "fedcba9876543210\n/root/Storage/Game/start.sh") + self.write("apps/game/entry", "start.sh") + imports = {"appimage": (str(self.tmp / "user"), "app"), "folder": (str(self.tmp / "apps"), "entry")} + with mock.patch.dict(OPEN, {"IMPORTS": imports}): + self.assertEqual(OPEN["import_of"]("0123456789abcdef", "appimage"), str(self.tmp / "user/eden")) + self.assertIsNone(OPEN["import_of"]("fedcba9876543210", "appimage")) + self.assertEqual(OPEN["import_of"]("fedcba9876543210", "folder"), str(self.tmp / "apps/game")) + + +class GameFolderTest(Temp): + def setUp(self): + super().setUp() + self.storage = self.tmp / "storage" + patcher = mock.patch.dict(OPEN, {"noexec": lambda path: True, "storage_root": lambda folder: str(self.storage)}) + patcher.start() + self.addCleanup(patcher.stop) + + def folder(self, path): + return OPEN["game_folder"](str(self.storage / path)) + + def test_a_native_games_folder_on_noexec_storage_is_copied_in(self): + self.write("storage/Download/Game/start.sh", b"#!/bin/sh\n./bin/game.aarch64\n") + self.write("storage/Download/Game/bin/game.aarch64", elf(183)) + self.write("storage/Download/Godot/Game.arm64", elf(183)) + self.write("storage/Download/Godot/libgodot.so", elf(183)) + self.write("storage/MyGame/start.sh", b"./game\n") + self.write("storage/MyGame/game", elf(183)) + self.assertEqual(self.folder("Download/Game/start.sh"), str(self.storage / "Download/Game")) + self.assertEqual(self.folder("Download/Godot/Game.arm64"), str(self.storage / "Download/Godot")) + self.assertEqual(self.folder("MyGame/start.sh"), str(self.storage / "MyGame")) + + def test_x86_games_run_where_they_lie(self): + self.write("storage/Download/Game/start.sh", b"#!/bin/sh\n./bin/game.x86_64\n") + self.write("storage/Download/Game/bin/game.x86_64", elf(62)) + self.write("storage/Download/Unity/Game.x86_64", elf(62)) + self.write("storage/Download/Unity/UnityPlayer.so", elf(62)) + self.write("storage/Download/Old/game", elf(3)) + for path in ("Download/Game/start.sh", "Download/Unity/Game.x86_64", "Download/Old/game"): + with self.subTest(path): + self.assertIsNone(self.folder(path)) + + def test_what_runs_where_it_lies_is_left_there(self): + self.write("storage/Download/Scripts/hello.sh", b"echo hi\n") + self.write("storage/Download/Tool/tool", elf(183)) + self.write("storage/Download/start.sh", b"./Tool/tool\n") + self.write("storage/start.sh", b"./Download/Tool/tool\n") + self.write("storage/Download/Deep/a/b/c/d/lib.so", elf(183)) + self.write("storage/Download/Deep/start.sh", b"echo\n") + for path in ("Download/Scripts/hello.sh", "Download/Tool/tool", "Download/start.sh", "start.sh", "Download/Deep/start.sh"): + with self.subTest(path): + self.assertIsNone(self.folder(path)) + self.write("internal/Game/start.sh", b"./game\n") + self.write("internal/Game/game", elf(183)) + with mock.patch.dict(OPEN, {"noexec": lambda path: False}): + self.assertIsNone(OPEN["game_folder"](str(self.tmp / "internal/Game/start.sh"))) + + def test_the_app_copies_the_folder_in_once(self): + script = self.write("storage/Download/Game/start.sh", b"./game\n") + launch = self.tmp / "launch" + launch.mkdir() + copy = self.tmp / "apps/game" + copy.mkdir(parents=True) + (copy / "entry").write_text("start.sh") + requests = [] + + def app(): + while not requests: + for request in launch.glob("desktop-import-*.request"): + requests.append(request.read_text()) + request.unlink() + (launch / request.name.replace(".request", ".result")).write_text("ok %s\n" % copy) + time.sleep(0.05) + + worker = threading.Thread(target=app) + worker.start() + imports = {what: (str(self.tmp / "none"), made) for what, (_, made) in OPEN["IMPORTS"].items()} + with mock.patch.dict(os.environ, {"BL_LAUNCH_DIR": str(launch)}), \ + mock.patch.dict(OPEN, {"CACHE": str(self.tmp / "cache"), "IMPORTS": imports, "notify": lambda *a: None}): + self.assertEqual(OPEN["command"](str(script), ["-x"], "folder"), ([OPEN["SCRIPT_RUN"], str(copy), "-x"], str(script.parent))) + worker.join() + self.assertRegex(requests[0], "^id=[0-9a-f]{16}\nkind=folder\npath=%s\n$" % script) + + +def appinfo(apps): + """appinfo.vdf as the client writes it (format 29: keys in a string table).""" + strings = [] + + def key(name): + if name not in strings: + strings.append(name) + return struct.pack(" +#include +#include +#include + +int main(int argc, char **argv) { + if (argc < 2) return 2; + int fd = open(argv[1], O_RDONLY); + void *code = mmap(NULL, 4096, PROT_READ | PROT_EXEC, MAP_PRIVATE, fd, 0); + printf("map %d\n", code == MAP_FAILED ? errno : 0); + void *data = mmap(NULL, 4096, PROT_READ, MAP_PRIVATE, fd, 0); + printf("protect %d\n", mprotect(data, 4096, PROT_READ | PROT_EXEC) ? errno : 0); + printf("read %c\n", code == MAP_FAILED ? '-' : *(char *)code); + return 0; +} +""" + + +def noexec_folder(): + for folder in ("/run/lock", "/dev/shm", "/run/user/%d" % os.getuid()): + try: + if os.access(folder, os.W_OK) and os.statvfs(folder).f_flag & os.ST_NOEXEC: + return folder + except OSError: + pass + return None + + +@unittest.skipUnless(shutil.which("cc") and noexec_folder(), "needs cc and a writable noexec mount") +class NoexecPreloadTest(unittest.TestCase): + @classmethod + def setUpClass(cls): + cls.tmp = Path(tempfile.mkdtemp()) + cls.lib = cls.tmp / "libnoexec.so" + subprocess.run(["cc", "-O2", "-Wall", "-Werror", "-fPIC", "-shared", "-pthread", "-DNOEXEC_TEST", "-o", str(cls.lib), + str(PRELOAD / "noexec.c"), str(PRELOAD / "fsync.c"), str(PRELOAD / "robust.c"), "-ldl"], check=True) + source = cls.tmp / "program.c" + source.write_text(PROGRAM) + for name in ("FEX", "game"): + subprocess.run(["cc", "-O2", "-o", str(cls.tmp / name), str(source)], check=True) + cls.target = Path(tempfile.mkdtemp(dir=noexec_folder())) / "Game.x86_64" + cls.target.write_bytes(b"\x7fELF" + bytes(4092)) + + @classmethod + def tearDownClass(cls): + shutil.rmtree(cls.tmp, ignore_errors=True) + shutil.rmtree(cls.target.parent, ignore_errors=True) + + def run_as(self, name, preload=True): + env = dict(os.environ, LD_PRELOAD=str(self.lib)) if preload else {k: v for k, v in os.environ.items() if k != "LD_PRELOAD"} + result = subprocess.run([str(self.tmp / name), str(self.target)], env=env, capture_output=True, text=True, check=True) + return result.stdout.split("\n")[:3] + + def test_fex_maps_a_program_on_noexec_storage(self): + self.assertEqual(self.run_as("FEX"), ["map 0", "protect 0", "read \x7f"]) + + def test_the_kernel_still_refuses_everyone_else(self): + for refused in (self.run_as("game"), self.run_as("FEX", preload=False)): + self.assertIn(refused[0], ("map 1", "map 13")) + self.assertEqual(refused[1:], ["protect 13", "read -"]) + + +if __name__ == "__main__": + unittest.main() diff --git a/tools/tests/test_steam_compat_live.py b/tools/tests/test_steam_compat_live.py index 7b311ad58..a20ffba2f 100644 --- a/tools/tests/test_steam_compat_live.py +++ b/tools/tests/test_steam_compat_live.py @@ -6,6 +6,7 @@ import shutil import subprocess import tempfile import unittest +from unittest import mock BIN = Path(__file__).resolve().parents[1] / "linuxfs/overlay/usr/local/bin" LIVE = runpy.run_path(str(BIN / "droiddeck-steam-compat")) @@ -214,5 +215,92 @@ class ReconcileTest(unittest.TestCase): self.assertFalse(COMPAT["live_helper_running"]()) +SWITCH_HARNESS = r""" +const sent = [], asked = []; +class FakeSocket { send(data) { sent.push(data); } } +globalThis.window = globalThis; +globalThis.WebSocket = FakeSocket; +window.droiddeckSwitchToDesktop = (x) => asked.push(x); +const install = require("fs").readFileSync(process.argv[2], "utf8"); +const frame = (method) => { + const name = new TextEncoder().encode(method), h = [0x51, 1, 0, 0, 0, 0, 0, 0, 0, 0x62, name.length, ...name]; + const out = new Uint8Array(8 + h.length), dv = new DataView(out.buffer); + dv.setUint32(0, (0x80000000 | 146) >>> 0, true); dv.setUint32(4, h.length, true); out.set(h, 8); + return out; +}; +if (eval(install) !== "installed" || eval(install) !== "present") throw new Error("install is not idempotent"); +const ws = new FakeSocket(); +ws.send(frame("CompatManager.GetCompatTools#1")); +ws.send(frame("SteamOSManager.SwitchToDesktop#1").buffer); +ws.send(frame("SteamOSManager.SwitchToDesktop#1")); +ws.send("SteamOSManager.SwitchToDesktop#1"); +console.log(JSON.stringify({ sent: sent.length, asked: asked.length })); +""" + + +@unittest.skipUnless(shutil.which("node"), "node is not installed") +class SwitchScriptTest(unittest.TestCase): + def test_the_request_is_reported_and_still_sent(self): + with tempfile.TemporaryDirectory() as tmp: + script = Path(tmp) / "switch.js" + script.write_text(LIVE["SWITCH_JS"]) + harness = Path(tmp) / "harness.js" + harness.write_text(SWITCH_HARNESS) + result = subprocess.run(["node", str(harness), str(script)], capture_output=True, text=True, timeout=60) + self.assertEqual(result.returncode, 0, result.stderr) + self.assertEqual(json.loads(result.stdout), {"sent": 4, "asked": 2}) + + +class AttachPage: + def __init__(self, port, path): + self.calls, self.scripts = [], [] + self.ws = mock.Mock() + + def evaluate(self, expression, timeout=30): + self.scripts.append(expression) + return True + + def call(self, method, params=None, timeout=30): + self.calls.append((method, (params or {}).get("name"))) + return {} + + def compat(self, call): + return {"selected": "", "fallback": "", "tools": []} + + +class SwitchToDesktopTest(unittest.TestCase): + def setUp(self): + self.globals = LIVE["Helper"].attach.__globals__ + patcher = mock.patch.dict(self.globals, {"shared_context": lambda port: "/devtools/page/1", "Page": AttachPage}) + patcher.start() + self.addCleanup(patcher.stop) + + def test_only_a_client_without_its_steamos_manager_is_watched(self): + helper = LIVE["Helper"]("/steam", 1, steamos=False) + helper.attach() + self.assertIn(("Runtime.addBinding", LIVE["SWITCH_BINDING"]), helper.page.calls) + self.assertIn(LIVE["SWITCH_JS"], helper.page.scripts) + helper = LIVE["Helper"]("/steam", 1, steamos=True) + helper.attach() + self.assertNotIn(("Runtime.addBinding", LIVE["SWITCH_BINDING"]), helper.page.calls) + self.assertNotIn(LIVE["SWITCH_JS"], helper.page.scripts) + + def test_the_request_goes_to_steamos_session_select(self): + helper = LIVE["Helper"]("/steam", 1) + helper.page = mock.Mock() + helper.page.drain.return_value = [ + {"method": "Runtime.bindingCalled", "params": {"name": LIVE["BINDING"], "payload": "1"}}, + {"method": "Runtime.bindingCalled", "params": {"name": LIVE["SWITCH_BINDING"], "payload": ""}}, + ] + with mock.patch.object(self.globals["subprocess"], "call", return_value=0) as call: + events = helper.drain() + call.assert_called_once_with(["/usr/bin/steamos-session-select", "plasma"]) + self.assertTrue(any(LIVE["called"](e, LIVE["BINDING"]) for e in events)) + helper.page.drain.return_value = [{"method": "Runtime.bindingCalled", "params": {"name": LIVE["BINDING"]}}] + with mock.patch.object(self.globals["subprocess"], "call") as call: + helper.drain() + call.assert_not_called() + + if __name__ == "__main__": unittest.main() diff --git a/tools/tests/test_steam_libraries.py b/tools/tests/test_steam_libraries.py index 757e459a7..3987470ba 100644 --- a/tools/tests/test_steam_libraries.py +++ b/tools/tests/test_steam_libraries.py @@ -147,6 +147,19 @@ class DesktopGamesTest(unittest.TestCase): patch.object(desktop, "LIBRARIES", ((str(steam), "Steam Games"), (str(root / "card"), "SD Games"))): self.assertEqual({40: "Internal", 50: "Outside"}, desktop.write_entries()) + def test_runtimes_and_compatibility_tools_get_none(self): + with tempfile.TemporaryDirectory() as temp: + root = Path(temp) + steam = root / "Steam" + manifest(steam / "steamapps", 40, name="Game") + manifest(steam / "steamapps", 1628350, name="Steam Linux Runtime 3.0 (sniper)", installdir="SteamLinuxRuntime_sniper") + manifest(steam / "steamapps", 5000, name="Some Proton", installdir="Some Proton") + (steam / "steamapps/common/Some Proton").mkdir(parents=True) + (steam / "steamapps/common/Some Proton/toolmanifest.vdf").write_text('"manifest"\n{\n}\n') + with patch.object(desktop, "STEAM_ROOT", str(steam)), patch.object(desktop, "APPS_DIR", str(root / "apps")), \ + patch.object(desktop, "LIBRARIES", ((str(steam), "Steam Games"),)): + self.assertEqual({40: "Game"}, desktop.write_entries()) + if __name__ == "__main__": unittest.main() From 0e225d0c6eb4878be22d4b5c0a20143f4198b392 Mon Sep 17 00:00:00 2001 From: MaxsTechReview Date: Sat, 10 Oct 2026 19:12:51 -0400 Subject: [PATCH 3/9] FEX: preload the fault report only where x86 loaders look (#551) Preload the FEX fault report only where x86 loaders look droiddeck-fex put the x86 libfaultreport.so in LD_PRELOAD, which FEX's own arm64 loader reads too - and FEXServer's, and every child FEX's - so each x86 start printed "ERROR: ld.so: object '.../libfaultreport.so' from LD_PRELOAD cannot be preloaded", and an i386 child added "wrong ELF class". It is now listed in the x86 runtime's own /etc/ld.so.preload, which only the loaders inside FEX read, as /usr/$LIB/droiddeck/libfaultreport.so. faultreport.c builds for i386 too, so 32-bit programs get the report as well instead of an error. --- .../launcher/session/SessionFiles.kt | 4 +- tools/linuxfs/build-x86-preloads.sh | 11 +++-- tools/linuxfs/fex/faultreport.c | 33 +++++++++++--- .../overlay/usr/local/bin/droiddeck-fex | 16 ++++--- tools/release/runtime_inputs.py | 1 + tools/tests/test_droiddeck_fex.py | 18 ++++++-- tools/tests/test_faultreport.py | 44 +++++++++++++++++++ 7 files changed, 104 insertions(+), 23 deletions(-) create mode 100644 tools/tests/test_faultreport.py 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 7d459bec6..f69e4c837 100644 --- a/app/src/main/java/com/droiddeck/launcher/session/SessionFiles.kt +++ b/app/src/main/java/com/droiddeck/launcher/session/SessionFiles.kt @@ -133,8 +133,8 @@ object SessionFiles { .map { "usr/local/lib/droiddeck-msitools/$it" } + listOf("NOTICE", "GPL-2", "GPL-3", "LGPL-2.1", "7zip-License", "7zip-unRarLicense").map { "usr/local/share/licenses/droiddeck-msitools/$it" } val fexPreloads = listOf("x86_64", "i386").flatMap { arch -> - listOf("libblsession.so", "libfakeinput.so").map { "$arch/$it" to "usr/local/lib/droiddeck-fex/$arch/$it" } - } + listOf("libfaultreport.so", "libthunkaudit.so", "libvulkan-thunk.so").map { "x86_64/$it" to "usr/local/lib/droiddeck-fex/x86_64/$it" } + listOf("libblsession.so", "libfakeinput.so", "libfaultreport.so").map { "$arch/$it" to "usr/local/lib/droiddeck-fex/$arch/$it" } + } + listOf("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", "usr/local/lib/droiddeck/uruntime" to "usr/local/lib/droiddeck/uruntime", diff --git a/tools/linuxfs/build-x86-preloads.sh b/tools/linuxfs/build-x86-preloads.sh index 793cad1c5..58e0dcefe 100755 --- a/tools/linuxfs/build-x86-preloads.sh +++ b/tools/linuxfs/build-x86-preloads.sh @@ -26,9 +26,14 @@ for arch in x86_64 i386; do fi done done -for name in faultreport thunkaudit; do - lib=$out/x86_64/lib$name.so - gcc -m64 -shared -fPIC -O2 -Wall -Wextra -nostdlib -fno-stack-protector -fno-builtin -fvisibility=hidden \ +for target in x86_64/faultreport i386/faultreport x86_64/thunkaudit; do + arch=${target%/*} name=${target#*/} + case $arch in + x86_64) bits=-m64 ;; + i386) bits=-m32 ;; + esac + lib=$out/$arch/lib$name.so + gcc $bits -shared -fPIC -O2 -Wall -Wextra -nostdlib -fno-stack-protector -fno-builtin -fvisibility=hidden \ -o "$lib" tools/linuxfs/fex/$name.c strip --strip-unneeded "$lib" if objdump -p "$lib" | grep -q NEEDED || [ -n "$(nm -D --undefined-only "$lib" 2>/dev/null)" ]; then diff --git a/tools/linuxfs/fex/faultreport.c b/tools/linuxfs/fex/faultreport.c index 83bba2423..c71dcd48e 100644 --- a/tools/linuxfs/fex/faultreport.c +++ b/tools/linuxfs/fex/faultreport.c @@ -1,15 +1,30 @@ -#if !defined(__x86_64__) -#error faultreport is built for x86_64 guests only -#endif - +#if defined(__x86_64__) #define SYS_read 0 #define SYS_write 1 #define SYS_close 3 #define SYS_rt_sigaction 13 +#define SYS_rt_sigreturn "15" #define SYS_getpid 39 #define SYS_gettid 186 #define SYS_tgkill 234 #define SYS_openat 257 +#define SI_ADDR 16 +#define TRAP "syscall" +#elif defined(__i386__) +#define SYS_read 3 +#define SYS_write 4 +#define SYS_close 6 +#define SYS_rt_sigaction 174 +#define SYS_rt_sigreturn "173" +#define SYS_getpid 20 +#define SYS_gettid 224 +#define SYS_tgkill 270 +#define SYS_openat 295 +#define SI_ADDR 12 +#define TRAP "int $0x80" +#else +#error faultreport is built for x86 guests only +#endif #define AT_FDCWD (-100) #define SIGILL 4 #define SA_SIGINFO 0x4UL @@ -21,14 +36,18 @@ struct kernel_sigaction { void (*handler)(int, void *, void *); unsigned long flags; void (*restorer)(void); - unsigned long mask; + unsigned long long mask; }; static long sys(long n, long a, long b, long c, long d) { long r; +#if defined(__x86_64__) register long r10 __asm__("r10") = d; __asm__ volatile("syscall" : "=a"(r) : "a"(n), "D"(a), "S"(b), "d"(c), "r"(r10) : "rcx", "r11", "memory"); +#else + __asm__ volatile("int $0x80" : "=a"(r) : "a"(n), "b"(a), "c"(b), "d"(c), "S"(d) : "memory"); +#endif return r; } @@ -100,7 +119,7 @@ static int find_mapping(unsigned long addr, const char **line, unsigned long *le static void report(int sig, void *info, void *context) { (void)context; - unsigned long addr = *(unsigned long *)((char *)info + 16); + unsigned long addr = *(unsigned long *)((char *)info + SI_ADDR); int code = *(int *)((char *)info + 8); used = 0; put("droiddeck-fex: SIGILL at 0x"); @@ -135,7 +154,7 @@ static void report(int sig, void *info, void *context) } void faultreport_restore(void); -__asm__(".text\n.type faultreport_restore,@function\nfaultreport_restore:\nmov $15, %eax\nsyscall\nhlt\n"); +__asm__(".text\n.type faultreport_restore,@function\nfaultreport_restore:\nmov $" SYS_rt_sigreturn ", %eax\n" TRAP "\nhlt\n"); __attribute__((constructor)) static void install(void) { diff --git a/tools/linuxfs/overlay/usr/local/bin/droiddeck-fex b/tools/linuxfs/overlay/usr/local/bin/droiddeck-fex index 4a5967012..22519f09b 100755 --- a/tools/linuxfs/overlay/usr/local/bin/droiddeck-fex +++ b/tools/linuxfs/overlay/usr/local/bin/droiddeck-fex @@ -34,7 +34,6 @@ LAYOUT = 1 GUEST_LIBDIRS = (("x86_64", "lib/x86_64-linux-gnu"), ("i386", "lib/i386-linux-gnu")) PRELOAD_NAMES = ("libblsession.so", "libfakeinput.so") FAULT_REPORT = "libfaultreport.so" -FAULT_REPORT_GUEST = "/usr/lib/x86_64-linux-gnu/droiddeck/" + FAULT_REPORT THUNK_AUDIT = "libthunkaudit.so" THUNK_AUDIT_GUEST = "/usr/lib/x86_64-linux-gnu/droiddeck/" + THUNK_AUDIT VULKAN_PIN = "libvulkan-thunk.so" @@ -241,18 +240,23 @@ def host_preloads(): def install_preloads(root): - shipped = set() + shipped = {} for arch, libdir in GUEST_LIBDIRS: - for name in PRELOAD_NAMES: + for name in PRELOAD_NAMES + (FAULT_REPORT,): source = os.path.join(PRELOADS, arch, name) if os.path.isfile(source): copy_if_changed(source, os.path.join(root, libdir, "droiddeck", name)) - shipped.add(name) - for name in (FAULT_REPORT, THUNK_AUDIT, VULKAN_PIN): + shipped.setdefault(name, set()).add(arch) + for name in (THUNK_AUDIT, VULKAN_PIN): source = os.path.join(PRELOADS, "x86_64", name) if os.path.isfile(source): copy_if_changed(source, os.path.join(root, "lib/x86_64-linux-gnu/droiddeck", name)) wanted = [name for name in host_preloads() if name in shipped] + # The fault report is preloaded from the runtime's own list, which only x86 loaders read: through + # LD_PRELOAD it reached FEX's own loader too, and every FEX after it, which could not open it and + # said so at each start. Listed only with both builds, or i386 programs would say so instead. + if len(shipped.get(FAULT_REPORT, ())) == len(GUEST_LIBDIRS): + wanted.append(FAULT_REPORT) write_if_changed(os.path.join(root, "etc", "ld.so.preload"), "".join("/usr/$LIB/droiddeck/%s\n" % name for name in wanted)) @@ -502,8 +506,6 @@ def launch(command, env, mode, decide=None): return 126 guest = guest_environment(fex, env) x86_64 = elf_arch(program) != "i386" - if os.path.isfile(os.path.join(PRELOADS, "x86_64", FAULT_REPORT)) and x86_64: - guest["LD_PRELOAD"] = ":".join([FAULT_REPORT_GUEST] + split_paths(guest.get("LD_PRELOAD"))) thunks = "on" if "FEX_THUNKCONFIG" in guest else "off" folder = decide if decide and os.path.isdir(decide) else os.path.dirname(program) if thunks == "on" and x86_64 and all(os.path.isfile(os.path.join(PRELOADS, "x86_64", name)) for name in (THUNK_AUDIT, VULKAN_PIN)) \ diff --git a/tools/release/runtime_inputs.py b/tools/release/runtime_inputs.py index 78deb433c..b332ee36a 100644 --- a/tools/release/runtime_inputs.py +++ b/tools/release/runtime_inputs.py @@ -59,6 +59,7 @@ def required(): paths += ['assets/linuxfs/' + arch + '/' + lib for lib in ['libfakeinput.so', 'libblsession.so']] paths += ['assets/linuxfs/x86_64/' + lib for lib in ['libfaultreport.so', 'libthunkaudit.so', 'libvulkan-thunk.so']] + paths += ['assets/linuxfs/i386/libfaultreport.so'] paths += ['assets/linuxfs/usr/local/lib/droiddeck-msitools/' + name for name in ['msiinfo', 'cabextract', '7z', '7z.so', 'libmsi-1.0.so.0', 'libgsf-1.so.114', 'libgcab-1.0.so.0']] paths += ['assets/linuxfs/usr/local/lib/mangoapp/' + name for name in diff --git a/tools/tests/test_droiddeck_fex.py b/tools/tests/test_droiddeck_fex.py index c9d927f9e..20ccad022 100644 --- a/tools/tests/test_droiddeck_fex.py +++ b/tools/tests/test_droiddeck_fex.py @@ -198,12 +198,10 @@ class PrepareTest(FexTestCase): for arch in ("x86_64", "i386"): for name in ("libblsession.so", "libfakeinput.so"): self.write(self.tmp / "preloads" / arch / name, arch.encode() + name.encode()) - self.write(self.tmp / "preloads/x86_64/libfaultreport.so", b"report") self.write(self.tmp / "preloads/x86_64/libthunkaudit.so", b"audit") self.write(self.tmp / "preloads/x86_64/libvulkan-thunk.so", b"pin") self.write(self.tmp / "ld.so.preload", "/usr/local/lib/libblsession.so\n/usr/local/lib/libfakeinput.so\n") FEX["install_preloads"](str(root)) - self.assertEqual((root / "lib/x86_64-linux-gnu/droiddeck/libfaultreport.so").read_bytes(), b"report") self.assertEqual((root / "lib/x86_64-linux-gnu/droiddeck/libthunkaudit.so").read_bytes(), b"audit") self.assertEqual((root / "lib/x86_64-linux-gnu/droiddeck/libvulkan-thunk.so").read_bytes(), b"pin") self.assertEqual((root / "etc/ld.so.preload").read_text(), @@ -213,6 +211,17 @@ class PrepareTest(FexTestCase): FEX["install_preloads"](str(root)) self.assertEqual((root / "etc/ld.so.preload").read_text(), "/usr/$LIB/droiddeck/libblsession.so\n") + def test_only_x86_loaders_preload_the_fault_report(self): + root = self.tmp / "root" + self.write(self.tmp / "preloads/x86_64/libfaultreport.so", b"report64") + FEX["install_preloads"](str(root)) + self.assertNotIn("libfaultreport.so", (root / "etc/ld.so.preload").read_text()) + self.write(self.tmp / "preloads/i386/libfaultreport.so", b"report32") + FEX["install_preloads"](str(root)) + self.assertEqual((root / "lib/x86_64-linux-gnu/droiddeck/libfaultreport.so").read_bytes(), b"report64") + self.assertEqual((root / "lib/i386-linux-gnu/droiddeck/libfaultreport.so").read_bytes(), b"report32") + self.assertEqual((root / "etc/ld.so.preload").read_text(), "/usr/$LIB/droiddeck/libfaultreport.so\n") + def test_config_turns_thunks_on_only_when_complete(self): FEX["write_config"]({"host_thunks": "/h", "guest_thunks": "/g", "thunks_db": "/db"}, "/root") config = json.loads((self.home / ".local/share/droiddeck-fex/config/Config.json").read_text()) @@ -385,11 +394,12 @@ class LaunchTest(FexTestCase): self.assertEqual(env["FEX_PORTABLE"], "1") self.assertNotIn("LD_PRELOAD", env) self.assertEqual(env["FEX_ROOTFS"], str(self.steam / "steamapps/common/SteamLinuxRuntime_sniper/sniper_platform_3.0.20260805.254768/files")) - self.write(self.tmp / "preloads/x86_64/libfaultreport.so", elf(62)) + for arch in ("x86_64", "i386"): + self.write(self.tmp / "preloads" / arch / "libfaultreport.so", elf(62 if arch == "x86_64" else 3)) x86 = self.write(self.tmp / "x86.so", elf(62)) with mock.patch("os.execve") as emulated: self.quiet(FEX["launch"], [str(program)], {"LD_PRELOAD": str(x86)}, "auto") - self.assertEqual(emulated.call_args[0][2]["LD_PRELOAD"], "/usr/lib/x86_64-linux-gnu/droiddeck/libfaultreport.so:%s" % x86) + self.assertEqual(emulated.call_args[0][2]["LD_PRELOAD"], str(x86)) old = self.write(self.tmp / "game.i386", elf(3), 0o755) with mock.patch("os.execve") as emulated: self.quiet(FEX["launch"], [str(old)], {}, "auto") diff --git a/tools/tests/test_faultreport.py b/tools/tests/test_faultreport.py new file mode 100644 index 000000000..2c9a329db --- /dev/null +++ b/tools/tests/test_faultreport.py @@ -0,0 +1,44 @@ +import os +from pathlib import Path +import shutil +import subprocess +import tempfile +import unittest + +SOURCE = Path(__file__).resolve().parents[1] / "linuxfs/fex/faultreport.c" +PROGRAM = 'int main(void) { __asm__ volatile("ud2"); return 0; }\n' +FLAGS = ["-shared", "-fPIC", "-O2", "-Wall", "-Wextra", "-Werror", "-nostdlib", "-fno-stack-protector", "-fno-builtin", + "-fvisibility=hidden"] + + +@unittest.skipUnless(shutil.which("gcc") and os.uname().machine == "x86_64", "needs gcc on an x86-64 host") +class FaultReportTest(unittest.TestCase): + def setUp(self): + self.tmp = Path(tempfile.mkdtemp()) + self.addCleanup(shutil.rmtree, self.tmp, ignore_errors=True) + (self.tmp / "program.c").write_text(PROGRAM) + + def build(self, bits): + library, program = self.tmp / ("libfaultreport%s.so" % bits), self.tmp / ("program%s" % bits) + if subprocess.run(["gcc", "-m" + bits, "-o", str(program), str(self.tmp / "program.c")], capture_output=True).returncode: + self.skipTest("gcc cannot build %s-bit programs here" % bits) + made = subprocess.run(["gcc", "-m" + bits] + FLAGS + ["-o", str(library), str(SOURCE)], capture_output=True, text=True) + self.assertEqual(made.returncode, 0, made.stderr) + return library, program + + def check(self, bits): + library, program = self.build(bits) + result = subprocess.run([str(program)], env=dict(os.environ, LD_PRELOAD=str(library)), capture_output=True, text=True) + self.assertEqual(result.returncode, -4) + self.assertRegex(result.stderr, r"droiddeck-fex: SIGILL at 0x[0-9a-f]+ \(si_code 02\), offset 0x[0-9a-f]+, bytes 0f 0b ") + self.assertIn("program%s" % bits, result.stderr) + + def test_an_x86_64_program_reports_its_illegal_instruction(self): + self.check("64") + + def test_an_i386_program_reports_its_illegal_instruction(self): + self.check("32") + + +if __name__ == "__main__": + unittest.main() From d1b0ac4df110987534ec766b08b04f68f5f7c654 Mon Sep 17 00:00:00 2001 From: The412Banner <205237651+The412Banner@users.noreply.github.com> Date: Sat, 10 Oct 2026 21:15:56 -0400 Subject: [PATCH 4/9] Windows components: picked automatically by each game's source (#554) Each game's Windows components now come from the list its own source trusts, and the ones that list names turn on by themselves. The user's own on/off switches always win; each automatic row says why it is on. - Steam games: the Steamworks Shared redistributables Steam installs with the game (appmanifest SharedDepots, else the client's appinfo.vdf). Steam keeps its install scripts marked as already run. - GOG: the build manifest's dependencies. Epic: the manifest's prerequisite (Unreal's maps to VC++ and DirectX). Amazon: fuel.json PostInstall. Older GOG/Epic installs get their list fetched once with the saved sign-in; game files are never downloaded again. - Custom games (the + button, Add all, migrated folders): one shared Steam match per game, also used for artwork. An appid from the game's files turns components on; a name-only match stays Recommended; no match falls back to the folder scan. - Steam app info for apps the client never saw comes from an anonymous Steam PICS lookup (CM websocket, anonymous logon, product info), cached per appid; the user's Steam sign-in is never used. - Missing components download in the background on one low-priority worker that pauses during sessions and waits on battery saver, heat or a metered network unless the user asked. A game Steam installs during a session is readied right away so it can be played without ending the session; the launch waits up to 10 s only for a component still on its way. - Page: "On for this game" with reasons, a quiet "Checking what this game needs..." only for games never worked out, rows that ease in, pieces that need a download greyed out while offline. The intro names no other app. - The folder scan skips Unity's *_Data/Managed (Mono, not .NET Framework). --- .../com/droiddeck/launcher/MainActivity.kt | 46 +- .../launcher/frontend/AddedGameArt.kt | 25 +- .../launcher/frontend/AutoComponents.kt | 419 +++++++++ .../launcher/frontend/DependencyDetector.kt | 16 + .../launcher/frontend/SessionInstalls.kt | 95 ++ .../launcher/frontend/SteamAppInfo.kt | 202 ++++ .../droiddeck/launcher/frontend/SteamMatch.kt | 77 ++ .../droiddeck/launcher/frontend/SteamPics.kt | 334 +++++++ .../launcher/frontend/StoreListBackfill.kt | 98 ++ .../launcher/frontend/WinCompSources.kt | 160 ++++ .../launcher/session/SessionService.kt | 2 + .../launcher/session/WinComponents.kt | 144 ++- .../launcher/stores/StoreInstalls.kt | 3 + .../launcher/stores/epic/EpicBackend.kt | 6 +- .../stores/epic/EpicDownloadManager.java | 42 +- .../launcher/stores/gog/GogBackend.kt | 3 + .../stores/gog/GogDownloadManager.java | 56 +- .../droiddeck/launcher/ui/FrontEndGames.kt | 20 +- .../droiddeck/launcher/ui/FrontEndSetup.kt | 1 + .../launcher/ui/WinComponentsEditor.kt | 311 ++++-- app/src/main/res/values-es/strings.xml | 22 +- app/src/main/res/values-ja/strings.xml | 20 +- app/src/main/res/values-ko/strings.xml | 20 +- app/src/main/res/values-zh-rCN/strings.xml | 20 +- app/src/main/res/values-zh-rHK/strings.xml | 20 +- app/src/main/res/values-zh-rTW/strings.xml | 20 +- app/src/main/res/values/strings.xml | 21 +- .../frontend/AddedGameArtLookupTest.kt | 39 +- .../launcher/frontend/SteamPicsTest.kt | 95 ++ .../launcher/frontend/WinCompSourcesTest.kt | 465 +++++++++ .../test/resources/steam-pics/app_2054970.vdf | 882 ++++++++++++++++++ .../development/windows-components-sources.md | 116 +++ docs/progress-log.md | 61 ++ .../usr/local/bin/droiddeck-wincomponents | 40 +- tools/tests/test_wincomponents.py | 55 +- 35 files changed, 3810 insertions(+), 146 deletions(-) create mode 100644 app/src/main/java/com/droiddeck/launcher/frontend/AutoComponents.kt create mode 100644 app/src/main/java/com/droiddeck/launcher/frontend/SessionInstalls.kt create mode 100644 app/src/main/java/com/droiddeck/launcher/frontend/SteamAppInfo.kt create mode 100644 app/src/main/java/com/droiddeck/launcher/frontend/SteamMatch.kt create mode 100644 app/src/main/java/com/droiddeck/launcher/frontend/SteamPics.kt create mode 100644 app/src/main/java/com/droiddeck/launcher/frontend/StoreListBackfill.kt create mode 100644 app/src/main/java/com/droiddeck/launcher/frontend/WinCompSources.kt create mode 100644 app/src/test/java/com/droiddeck/launcher/frontend/SteamPicsTest.kt create mode 100644 app/src/test/java/com/droiddeck/launcher/frontend/WinCompSourcesTest.kt create mode 100644 app/src/test/resources/steam-pics/app_2054970.vdf create mode 100644 docs/development/windows-components-sources.md diff --git a/app/src/main/java/com/droiddeck/launcher/MainActivity.kt b/app/src/main/java/com/droiddeck/launcher/MainActivity.kt index 6179f9f5a..d1f17bf1f 100644 --- a/app/src/main/java/com/droiddeck/launcher/MainActivity.kt +++ b/app/src/main/java/com/droiddeck/launcher/MainActivity.kt @@ -366,6 +366,8 @@ class MainActivity : ComponentActivity() { } private var romsDir by mutableStateOf(null) private var steamGames by mutableStateOf>(emptyList()) + @Volatile private var componentSweepDone = false + @Volatile private var componentSweepSession: String? = null private var emulatorList by mutableStateOf>(emptyList()) private var runningLabel by mutableStateOf(null) private var logsEnabled by mutableStateOf(true) @@ -616,7 +618,15 @@ class MainActivity : ComponentActivity() { .putExtra(SessionService.EXTRA_STEAM_UI, "desktop"), steamSession = true) }, // A store game may need something done first (an Epic game its sign-in code). - onSteamGame = { g -> if (shortcutPicker) chooseGameShortcut(g) else com.droiddeck.launcher.stores.StoreLaunch.prepare(this, g) { launchGame(g) } }, + onSteamGame = { g -> + if (shortcutPicker) chooseGameShortcut(g) + else { + // The launch takes the Windows components already on; the game's list is + // looked at again in the background once the session is over. + com.droiddeck.launcher.frontend.AutoComponents.beforeLaunch(this, g) + com.droiddeck.launcher.stores.StoreLaunch.prepare(this, g) { launchGame(g) } + } + }, onGameShortcut = { g -> com.droiddeck.launcher.frontend.GameShortcuts.pin(this, g) }, onExportGameFile = { g -> pickGameExport(g) }, onSyncGameFiles = { pickGameExport(null) }, @@ -1447,6 +1457,8 @@ class MainActivity : ComponentActivity() { val fresh = folders.mapNotNull { f -> com.droiddeck.launcher.frontend.AddedGames.single(this, f)?.let { com.droiddeck.launcher.frontend.Library.addedGame(this, it) } } + // An added or edited game's Windows components, from its source's list. + fresh.forEach { com.droiddeck.launcher.frontend.AutoComponents.refreshLater(this, it) } ui.post { val paths = folders.toSet() steamGames = (steamGames.filterNot { it.library == Library.ADDED && it.gameFiles?.path in paths } + fresh).distinctBy { it.gameId } @@ -1608,13 +1620,39 @@ class MainActivity : ComponentActivity() { val scanGeneration = ++libraryScanGeneration if (shortcutPicker) shortcutLibraryScanning = true Thread({ - // One update with the whole list: the wall places games by their position in it, so a - // partial list first would shuffle every capsule when the rest arrived. LibraryCache - // covers the wait. + // Steam's own games first, from their manifests alone (quick), beside the added games + // already listed: a game Steam installed during the session shows as the session ends, + // without waiting for the added games' walk below. Its Windows components' list is + // queued then too, on the low-priority worker, so its page is usually ready. + if (ready) { + val quick = runCatching { Library.steamGames(this) }.getOrNull() + if (quick != null) ui.post { + if (scanGeneration == libraryScanGeneration && steamGames.isNotEmpty()) { + val before = steamGames.map { it.gameId }.toSet() + val fresh = quick.filter { it.gameId !in before } + if (fresh.isNotEmpty()) { + steamGames = (quick + steamGames.filter { it.library == Library.ADDED }).distinctBy { it.gameId } + fresh.forEach { com.droiddeck.launcher.frontend.AutoComponents.queueGame(this, it, asked = false) } + } + } + } + } + // Then one update with the whole list: the wall places games by their position in it, + // so a partial list first would shuffle every capsule when the rest arrived. + // LibraryCache covers the wait. val games = if (ready) Library.launchableGames(this) else emptyList() val emus = Library.emulators(this) { id -> DesktopCatalog.installed(this, id) != null } val all = games.distinctBy { it.gameId } if (ready) com.droiddeck.launcher.frontend.LibraryCache.save(this, all) + // Once per app start: the Steam games' Windows components from Steam's lists. + // Queued only, after the launcher has been up a little; the worker takes them one at a time. + // And again after each session (a game installed in it, files changed). + val endedSession = SessionState.sessionId.takeIf { !SessionState.running && it != null && it != componentSweepSession } + if (ready && (!componentSweepDone || endedSession != null)) { + componentSweepDone = true + endedSession?.let { componentSweepSession = it } + ui.postDelayed({ Thread({ com.droiddeck.launcher.frontend.AutoComponents.sweep(this, all) }, "components-sweep").start() }, 10_000) + } ui.post { if (scanGeneration == libraryScanGeneration) { steamGames = all diff --git a/app/src/main/java/com/droiddeck/launcher/frontend/AddedGameArt.kt b/app/src/main/java/com/droiddeck/launcher/frontend/AddedGameArt.kt index a29e43679..1fb5bb272 100644 --- a/app/src/main/java/com/droiddeck/launcher/frontend/AddedGameArt.kt +++ b/app/src/main/java/com/droiddeck/launcher/frontend/AddedGameArt.kt @@ -137,8 +137,7 @@ object AddedGameArt { val out = ArrayList