From b4ff83cf9fad3d62b4588cb26d234e87d27c0714 Mon Sep 17 00:00:00 2001 From: xXJsonDeruloXx Date: Fri, 2 Oct 2026 19:08:01 -0400 Subject: [PATCH] Recover Deck discovery mount IDs on older kernels --- app/src/main/cpp/fakeinput_steam.cpp | 70 +++++++++++++++++++++++++++- 1 file changed, 68 insertions(+), 2 deletions(-) diff --git a/app/src/main/cpp/fakeinput_steam.cpp b/app/src/main/cpp/fakeinput_steam.cpp index 8598ffeb4..95f074a7d 100644 --- a/app/src/main/cpp/fakeinput_steam.cpp +++ b/app/src/main/cpp/fakeinput_steam.cpp @@ -1958,14 +1958,80 @@ EXPORT int fstatat64(int dirfd, const char *path, struct stat64 *buf, int flags) return fstatat(dirfd, path, reinterpret_cast(buf), flags); } +// sd-device's path chase now requires a mount ID, which statx only supplies from Linux 5.8. +// Older handheld kernels still publish the real ID in fdinfo. Scope this compatibility path to +// libudev/libsystemd in the Deck-reading Steam client, and never invent a unique mount ID. +__attribute__((visibility("hidden"))) static bool deck_device_library(void *caller) { + Dl_info info; + if (!dladdr(caller, &info) || !info.dli_fname) return false; + const char *name = strrchr(info.dli_fname, '/'); + name = name ? name + 1 : info.dli_fname; + return !strncmp(name, "libudev.so", 10) || !strncmp(name, "libsystemd.so", 13); +} + +__attribute__((visibility("hidden"))) static bool deck_mount_id_from_fdinfo( + int dirfd, const char *path, int flags, struct statx *buf) { + static auto real_openat = reinterpret_cast(dlsym(RTLD_NEXT, "openat")); + static auto real_fstat = reinterpret_cast(dlsym(RTLD_NEXT, "fstat")); + int target; + if (!path || !*path) { + if (!(flags & AT_EMPTY_PATH)) return false; + target = dirfd == AT_FDCWD ? real_openat(AT_FDCWD, ".", O_PATH | O_CLOEXEC) : + syscall(SYS_fcntl, dirfd, F_DUPFD_CLOEXEC, 0); + } else { + target = real_openat(dirfd, path, O_PATH | O_CLOEXEC | + ((flags & AT_SYMLINK_NOFOLLOW) ? O_NOFOLLOW : 0)); + } + if (target < 0) return false; + struct stat st; + // Pin the inode and check it still matches the successful statx before adding information. + bool same = real_fstat(target, &st) == 0 && (buf->stx_mask & STATX_INO) && + st.st_ino == buf->stx_ino && major(st.st_dev) == buf->stx_dev_major && + minor(st.st_dev) == buf->stx_dev_minor; + char name[64]; + snprintf(name, sizeof(name), "/proc/self/fdinfo/%d", target); + int info = same ? real_openat(AT_FDCWD, name, O_RDONLY | O_CLOEXEC) : -1; + char value[512]; + ssize_t length = info >= 0 ? syscall(SYS_read, info, value, sizeof(value) - 1) : -1; + if (info >= 0) syscall(SYS_close, info); + syscall(SYS_close, target); + if (length < 0) return false; + value[length] = '\0'; + for (const char *line = value; line && *line;) { + unsigned long long id; + if (sscanf(line, "mnt_id: %llu", &id) == 1 && id > 0) { + buf->stx_mnt_id = id; + buf->stx_mask |= STATX_MNT_ID; + return true; + } + const char *next = strchr(line, '\n'); + line = next ? next + 1 : nullptr; + } + return false; +} + EXPORT int statx(int dirfd, const char *path, int flags, unsigned mask, struct statx *buf) { static auto real = reinterpret_cast(dlsym(RTLD_NEXT, "statx")); int result = real(dirfd, path, flags, mask, buf); int saved_errno = errno; + constexpr unsigned unique_mount_id = 0x4000; // STATX_MNT_ID_UNIQUE, newer than build headers. + if (result == 0 && (mask & STATX_MNT_ID) && + !(buf->stx_mask & (STATX_MNT_ID | unique_mount_id)) && fake_deck_enabled() && + process_is_steam_client() && deck_device_library(__builtin_return_address(0))) { + bool recovered = deck_mount_id_from_fdinfo(dirfd, path, flags, buf); + static std::atomic noted_success{false}, noted_failure{false}; + if (!(recovered ? noted_success : noted_failure).exchange(true)) + Logger::log("deck discovery: statx mount id %s for %s (returned mask=0x%x id=%llu)\n", + recovered ? "recovered from fdinfo" : "unavailable in fdinfo", + path && *path ? path : "(fd)", buf->stx_mask, + static_cast(buf->stx_mnt_id)); + } if (deck_discovery_enabled()) { std::string resolved = path_at(dirfd, path); - char type[48]; - snprintf(type, sizeof(type), "mode=0%o mask=0x%x", result == 0 ? buf->stx_mode : 0, mask); + char type[96]; + snprintf(type, sizeof(type), "mode=0%o request=0x%x returned=0x%x mnt_id=%llu", + result == 0 ? buf->stx_mode : 0, mask, result == 0 ? buf->stx_mask : 0, + result == 0 ? static_cast(buf->stx_mnt_id) : 0); note_deck_discovery("statx", resolved.c_str(), result, flags, type); } errno = saved_errno;