chore: consistent code branding (#2800)

* chore: consistent code branding

* fix: carry legacy overrides, queues and live sync rows across the rename

* fix: keep queued legacy overrides on a failed rename and separate merged queue entries
This commit is contained in:
Kurt Himebauch authored and GitHub committed 2026-11-17 23:31:26 -05:00
1 parent ad9348879d
commit eabcfc7b74
229 files changed
+2584 -2468

No files matched your search

+1 -1
View File
@@ -10,7 +10,7 @@ publishes it on the Steam Deck client channels. `droiddeck-steam-install` instal
Valve also publishes `steam_client_steamdeck_stable_linuxarm64`.
- `droiddeck-steam-install --channel` prints the channel in use. The session passes that value as
`-clientbeta` and writes it to `package/beta`. The two must match, or the client loops on rc 42.
- Setting: `BL_STEAM_CHANNEL`, otherwise `~/.config/droiddeck/steam-channel`, set to `beta` or
- Setting: `DD_STEAM_CHANNEL`, otherwise `~/.config/droiddeck/steam-channel`, set to `beta` or
`stable`. A set channel never changes on its own.
- With no setting, the client falls back to `steamdeck_stable` automatically. It stays on stable
(`package/droiddeck-channel`) until a setting says otherwise. The fallback happens:
+3 -3
View File
@@ -1,6 +1,6 @@
# Low-memory reclaim and userspace compression
The Steam session monitor uses the existing `libblsession.so` page-out request to reclaim
The Steam session monitor uses the existing `libddsession.so` page-out request to reclaim
private anonymous launcher memory. The default remains a request 20 seconds after game focus,
with five minutes between requests. With client compression enabled, low system headroom can
also trigger a request while a game is loading, before its first focused window.
@@ -58,7 +58,7 @@ percentage: Android's `lmkd` killed a session on a 7.5 GiB device with
kill. A world load added 1 GiB of GPU memory in about ten seconds, and compressing 1.4 GiB took
2.6 seconds, so the request has to leave room for both.
Performance > Compress idle game memory turns this off (`BL_ZRAM_IDLE=0`); launcher compression
Performance > Compress idle game memory turns this off (`DD_ZRAM_IDLE=0`); launcher compression
and the RAM cap are unaffected.
The session request runs when real headroom falls below a quarter of RAM (bounded to
@@ -71,7 +71,7 @@ for either to complete, so a slow launcher acknowledgement does not delay the ga
request finishes, its anonymous RSS remains reserved from the session's swap budget. Completion
and backoff are measured against the processes that received each request, even if a later scan
finds different processes. The session request targets processes that loaded
`libblsession.so`: the game, Wine and its services, and excludes Steam and hidden launchers.
`libddsession.so`: the game, Wine and its services, and excludes Steam and hidden launchers.
Requests are at least 30 seconds apart and need the same
swap reserve as launcher requests. When the session has read back more than half of what the
previous request compressed, that memory is in use: the request is skipped and the wait doubles,
+1 -1
View File
@@ -164,7 +164,7 @@ App (Kotlin/C):
- Gives a zero row pitch a packed 64-byte row (gamescope's 1x1 root buffer).
- `gpu/GpuInfo.kt`, `FrontEndActivity.kt`, `core/DeviceReport.kt`: wording, plus a "Venus" line in `device.txt`.
- `session/SessionFiles.kt`: stages the Mali compatibility layer when the APK carries it.
- `tools/linuxfs/preload/venus.c` (new, part of `libblsession`): unsets `LIBGL_KOPPER_DISABLE` when `VN_DEBUG` has `vtest`.
- `tools/linuxfs/preload/venus.c` (new, part of `libddsession`): unsets `LIBGL_KOPPER_DISABLE` when `VN_DEBUG` has `vtest`.
- Steam's `steamwebhelper.sh` sets it unconditionally.
- Without kopper and without DRI3, Zink gets no GL context, and the Steam UI crash-loops.
- Steam restores that script when it verifies its install, so it cannot be edited.
+9 -9
View File
@@ -47,7 +47,7 @@ waits; it does not establish a full-install PRoot overhead percentage.
```
SessionService ─HostProcess─▶ libproot.so (ONE tracer process, nice -6 after 2 s)
└─ /usr/bin/env -i … droiddeck-session steam
└─ gamescope ─▶ droiddeck-session (BL_INSIDE) ─▶ steamrtarm64/steam (+ steamwebhelper/CEF tree)
└─ gamescope ─▶ droiddeck-session (DD_INSIDE) ─▶ steamrtarm64/steam (+ steamwebhelper/CEF tree)
└─ reaper ─▶ droiddeck-game-env ─▶ droiddeck-proton ─▶ Valve ARM64 Proton (python)
└─ wine (arm64ec, FEX loaded in-process as a DLL) ─▶ wineserver, game.exe, …
```
@@ -56,7 +56,7 @@ SessionService ─HostProcess─▶ libproot.so (ONE tracer process, nice -6 aft
- The options are `--kill-on-exit`, `--kernel-release=…` (kompat, for the hostname), `-i uid:uid`
(fake_id0, for Xwayland's `setgid`/`setuid`), and about 25 binds: `/dev`, `/proc`, `/sys`, fake
`/proc` and `/sys` files, the GPU node, `/dev/shm`, storage and the game libraries.
- `/etc/ld.so.preload` loads `libblsession.so` (the `tools/linuxfs/preload/*.c` shims) into every
- `/etc/ld.so.preload` loads `libddsession.so` (the `tools/linuxfs/preload/*.c` shims) into every
guest process.
- The Flatpak sandboxes (`BwrapSpawner`) already run in **separate** proot instances, started from
the Android side.
@@ -187,9 +187,9 @@ Checked against bionic `android16-release`:
|---|---|---|
| `rseq`, `set_robust_list` | **blocked** | glibc, at the start of every thread, while all signals are blocked |
| `faccessat2` | **blocked** | glibc's `faccessat()`, which tries it on **every** call before falling back, so 2 round trips (`access()` calls the plain `faccessat` syscall directly) |
| `fchmodat2`, `openat2` | **blocked** | newer glibc, Flatpak/libglnx, FEX's rootfs lookups (`libblsession.so` turns `openat2` into `openat`, resolving `RESOLVE_IN_ROOT` paths component by component inside the root) |
| `fchmodat2`, `openat2` | **blocked** | newer glibc, Flatpak/libglnx, FEX's rootfs lookups (`libddsession.so` turns `openat2` into `openat`, resolving `RESOLVE_IN_ROOT` paths component by component inside the root) |
| `setuid`, `setgid` and the rest of the family | **blocked** | Xwayland (hence `-i`) |
| `futex_waitv`, `io_uring_*`, `landlock_*` | **blocked** | Proton's fsync (droiddeck-fsync answers `futex_waitv` in `libblsession.so`), some engines |
| `futex_waitv`, `io_uring_*`, `landlock_*` | **blocked** | Proton's fsync (droiddeck-fsync answers `futex_waitv` in `libddsession.so`), some engines |
| `clone3` | blocked before Android 15 | glibc `pthread_create` |
| `close_range` | blocked on Android 12 | |
| `statx`, `process_vm_readv`/`writev`, `memfd_create`, `pidfd_*`, `seccomp` | allowed | |
@@ -300,7 +300,7 @@ it needs `patches/0014`, enabled with `PROOT_FASTPATH=1`.
library file itself at the fixed address instead, as proot's loader does for every program.
- Nothing claims `0xffff00000` first.
- The stub's syscalls pass Android's filter. They should: all are allowed.
- **Integrate into `libblsession.so`** rather than a second preload. `opens.c` and `pathcache.c`
- **Integrate into `libddsession.so`** rather than a second preload. `opens.c` and `pathcache.c`
already define `open` and `access`, so their "real" call should become the fast path. That also
removes the second library's load cost, about 0.2–0.4 ms per exec that is still unexplained (see
the exec row above).
@@ -375,19 +375,19 @@ Build a **glibc ARM64** library using the same toolchain as the shipped fast pat
docker run --rm --platform linux/amd64 --user "$(id -u):$(id -g)" \
-v "$PWD:/src" -w /src droiddeck-local-cross:24.04-v3 \
aarch64-linux-gnu-gcc -shared -fPIC -O2 -Wall -pthread \
-o /src/libblfastpath.so tools/proot/fastpath/fastpath.c -ldl
-o /src/libddfastpath.so tools/proot/fastpath/fastpath.c -ldl
tools/droiddeckctl stop
tools/droiddeckctl override libblfastpath.so ./libblfastpath.so
tools/droiddeckctl override libddfastpath.so ./libddfastpath.so
tools/droiddeckctl proot-profile enable
tools/droiddeckctl start steam --wait
```
The existing override bridge now recognizes `libblfastpath.so`: it checks ELF class, endianness,
The existing override bridge now recognizes `libddfastpath.so`: it checks ELF class, endianness,
type, and machine, reports SHA-256, and selects that file in `/etc/ld.so.preload` for one session.
It rejects installation while a session is active. This is an architecture check, not validation
of libc compatibility or the library's behavior. The fast path still requires its normal enabled
setting and the patched PRoot pack. Its basename stays `libblfastpath.so`, so `libblsession`'s FEX
setting and the patched PRoot pack. Its basename stays `libddfastpath.so`, so `libddsession`'s FEX
routing finds it. Guest-command restaging retains the active selection. After stopping, the next
session stages the bundled preload again; `env clear all` cancels queued overrides.
+3 -3
View File
@@ -63,7 +63,7 @@ handles the same constraint with `libproot-loader.so`.
## Compared with DroidDeck
| | DroidDeck (proot + 0001–0018 + `libblfastpath.so`) | proroot |
| | DroidDeck (proot + 0001–0018 + `libddfastpath.so`) | proroot |
|---|---|---|
| exec, `PT_INTERP`, `/proc/self/exe` | proot's loader under ptrace, 0.4–0.8 ms per exec | Its own loaders, with no tracer; also needs its own ld.so with a glibc offset table |
| path calls through libc wrappers | fast path, about 0.6–1.9 µs | runtime hooks |
@@ -82,7 +82,7 @@ DroidDeck is as a fast path *in front of* proot.
## What is worth taking
1. **Patch glibc's svc sites from `libblfastpath.so`'s constructor.** This is the largest gain
1. **Patch glibc's svc sites from `libddfastpath.so`'s constructor.** This is the largest gain
and the cheapest way to do option 6 in [proot-performance](proot-performance.md) ("a proot-aware
glibc") without rebuilding glibc.
- For `libc.so.6` (and `ld-linux-aarch64.so.1` for runtime `dlopen`), rewrite each `svc #0`
@@ -136,7 +136,7 @@ netlink and SysV shm (`netif.c` and `sysv.c` already cover these); and the long-
`tools/proot/fastpath/svc-patch.h`, included by `fastpath.c`, implements the first
slice of item 1. It runs automatically in fresh processes using the replacement
`libblfastpath.so` when the ordinary fast-path configuration and tracer-key check
`libddfastpath.so` when the ordinary fast-path configuration and tracer-key check
succeed. Set `PROOT_FP_PATCH_SVC=0` to disable it for troubleshooting or comparisons;
`PROOT_FP_PATCH_SVC=1` also explicitly enables it. It skips processes that already have multiple threads,
and declines SVE/SME hardware because the relay preserves the base ARM64 register state.
+7 -7
View File
@@ -13,7 +13,7 @@ very high-resolution panels and on foldables?
## How the session is sized today (main @ c636eea3)
- `droiddeck-session` starts gamescope with `-W/-H` (output) = `-w/-h` (nested, what games and the
client see) = `BL_WIDTH x BL_HEIGHT`, the per-mode "Resolution" setting. The default is
client see) = `DD_WIDTH x DD_HEIGHT`, the per-mode "Resolution" setting. The default is
`1280x720` (`SessionDisplay.DEFAULT_RESOLUTION`). One Xwayland server holds both the Steam
client and the games.
- The Android compositor (`waylandcomp`) draws gamescope's output into a panel-sized swapchain
@@ -68,7 +68,7 @@ fullscreen off, with a spike build of `feat/steam-native-output`. Each run sets
Steam UI idle: GPU 0%, gamescope 27 dma-bufs, Xwayland 39. Everything renders at 1920x1080.
### Run 2: client height cap (`BL_STEAM_MAX_HEIGHT=720`)
### Run 2: client height cap (`DD_STEAM_MAX_HEIGHT=720`)
- Log: `== steam: the client's height capped at 720 (was unset)`. The client never wrote its own
value during the run, so a one-time set would hold.
@@ -173,15 +173,15 @@ restored): the session starts at `size=1280x720` and the device report shows `72
### How runs 2 to 6 were driven
Two temporary session-script hooks, not kept on this branch: `BL_STEAM_MAX_HEIGHT=N` wrote
`GAMESCOPE_STEAM_MAX_HEIGHT` on the root window, and `BL_GAME_XWAYLAND_MODE=WxH` wrote
Two temporary session-script hooks, not kept on this branch: `DD_STEAM_MAX_HEIGHT=N` wrote
`GAMESCOPE_STEAM_MAX_HEIGHT` on the root window, and `DD_GAME_XWAYLAND_MODE=WxH` wrote
`GAMESCOPE_XWAYLAND_MODE_CONTROL = 1,W,H,0` five seconds after `GAMESCOPE_FOCUSED_APP` showed a
game. `--xwayland-count 2` and `STEAM_MULTIPLE_XWAYLANDS=1` went through `Download/droiddeck-env`.
## Two Xwayland servers by default (`feat/steam-dual-xwayland`)
Steam sessions now start gamescope with `--xwayland-count 2` and `STEAM_MULTIPLE_XWAYLANDS=1`.
`BL_XWAYLAND_COUNT=1` in `Android/data/com.droiddeck.launcher/files/droiddeck-env` goes back to one. The session script's
`DD_XWAYLAND_COUNT=1` in `Android/data/com.droiddeck.launcher/files/droiddeck-env` goes back to one. The session script's
root-window requests that are meant for the game (the drawer's live Force fullscreen,
`GAMESCOPE_FORCE_WINDOWS_FULLSCREEN`, and the resume watcher's `GAMESCOPE_RESTORE_FOCUS_WINDOW`)
go to both displays, `$DISPLAY` and `STEAM_GAME_DISPLAY_0`. gamescope reads both per server, so
@@ -221,8 +221,8 @@ With games on their own Xwayland server, FlatOut 2 no longer shrinks under the Q
reason "Force game windows fullscreen" existed. What it still did was make any game whose Game
Resolution differs from what it draws fight it (runs 4 and 5). The switch is gone from Steam
settings (Games) and the session drawer (Display), along with its preference, the
`BL_GAMESCOPE_FORCE_FULLSCREEN` flag, the `~/.droiddeck-fill` live watcher and the device report
line. `BL_GAMESCOPE_ARGS=--force-windows-fullscreen` in `Android/data/com.droiddeck.launcher/files/droiddeck-env` still passes the
`DD_GAMESCOPE_FORCE_FULLSCREEN` flag, the `~/.droiddeck-fill` live watcher and the device report
line. `DD_GAMESCOPE_ARGS=--force-windows-fullscreen` in `Android/data/com.droiddeck.launcher/files/droiddeck-env` still passes the
flag for an experiment.
Device check (Thor): Alan Wake's American Nightmare with its 1280x720 Game Resolution runs on `:1`
+1 -1
View File
@@ -38,7 +38,7 @@ SteamTouchConfig (Steam's configs) ←─── output reports ←── Ste
- **Plugging.** The device is plugged in only while Steam's controls are shown: always in a Steam
session with that choice, since a handheld's built-in pad would keep Auto off for good. Unplugging
ends the device's report stream (the client lets the controller go); either way libfakeinput
sends a udev event through `udevmon.c`'s stand-in monitor (`bl_udevmon_inject`), since the
sends a udev event through `udevmon.c`'s stand-in monitor (`dd_udevmon_inject`), since the
sandbox gives the client no kernel uevents and its HID discovery would never look again.
## Layouts
+1 -1
View File
@@ -270,7 +270,7 @@ A game's web links reach Android: `droiddeck-store-launch` sets the prefix's
`HKCU\Software\Wine\WineBrowser` `Browsers` to `/usr/local/bin/droiddeck-open-url`, which is also
`xdg-open` first on the game's PATH, and hands http(s) addresses to the app, which opens them in
Android's browser. EOS uses this when a sign-in needs a one-time step ("corrective action"): it
falls back to a browser, the user approves on the phone, and the game signs in. `BL_DEBUG_BROWSER=1`
falls back to a browser, the user approves on the phone, and the game signs in. `DD_DEBUG_BROWSER=1`
in droiddeck-env adds `WINEDEBUG=+shell,+winebrowser`. Epic's EOS overlay is not provisioned (with
it games exited while loading); an `OverlayPath` an earlier build wrote is removed at launch. The
parked overlay work is on the branch `park/epic-eos-overlay`.
@@ -426,7 +426,7 @@ path.
still fall back.
Same workloads on the Thor, stock library against the new one (session started with
`droiddeckctl override libblfastpath.so`, PRoot profiler on):
`droiddeckctl override libddfastpath.so`, PRoot profiler on):
| Workload | Stock | New |
|---|---|---|
+23 -23
View File
@@ -2,7 +2,7 @@
Valve's x86-64 Linux Steam client, run unchanged under FEX beside the default arm64 client. It is
opt-in: Steam settings, **Steam client: x86-64** (`steamClientArch`, passed to the
session as `BL_STEAM_CLIENT_ARCH=x86_64`, applies from the next session), or the desktop menu entry
session as `DD_STEAM_CLIENT_ARCH=x86_64`, applies from the next session), or the desktop menu entry
**Steam x86-64 (FEX, experimental)**. The Library lists the active client's games and tags its
header "x86-64" while that client's list is shown. This page records why each workaround exists and what was seen
on devices. The timeline is in `docs/progress-log.md`.
@@ -11,7 +11,7 @@ on devices. The timeline is in `docs/progress-log.md`.
VAC-secured servers ("Connection Blocked ... VAC secured server") and no client log mentions VAC. VAC
modules are x86 code. Under FEX the x86-64 client has a module it can run, as SteamLite does in Wine.
**Layout.** Everything lives in its own home, `$X64_HOME` (`BL_X64_HOME`, default `~/.droiddeck-x64`):
**Layout.** Everything lives in its own home, `$X64_HOME` (`DD_X64_HOME`, default `~/.droiddeck-x64`):
its own `~/.steam` links, config, libraries, x86 rootfs and log (`steam-x64.log`). Shared with the arm64
client: the sign-in, and its `config/uioverrides` (Steam's startup movie overrides), which the x86 client
links. One client runs at a time, since both use the same account; the standalone launcher shuts the
@@ -76,7 +76,7 @@ arm64 client down first.
- **Tracer.** proot is a tracer, so tier0 believes a debugger is attached and breaks into it with int3
on the first failed assertion: the web helper died of SIGTRAP a second after every start.
`preload/tracer.c` exempts web helpers on purpose (Chromium traps on a status fd that is not
procfs); with `BL_WEBHELPER_HIDE_TRACER=1` only opens called from `libtier0_s.so` get the copy
procfs); with `DD_WEBHELPER_HIDE_TRACER=1` only opens called from `libtier0_s.so` get the copy
without the tracer.
- **FEXServer owns the rootfs.** A FEX process takes its rootfs from FEXServer, and a server started
earlier without `FEX_ROOTFS` (any FEX run in the guest) serves none: every x86 library lookup fell
@@ -86,7 +86,7 @@ arm64 client down first.
never got a browser up. FEX looks in the rootfs first, so an empty `rootfs/dev/dri` hides the node.
- **Scout runtime.** Valve ships it as `ubuntu12_32/steam-runtime.tar.xz` and `steam.sh` unpacks it.
Since `steam.sh` is not used, `--prepare` unpacks it when its checksum changes.
- **Repair.** Repair Steam (`BL_X64_REPAIR=1`), or two starts in a row that never showed the client
- **Repair.** Repair Steam (`DD_X64_REPAIR=1`), or two starts in a row that never showed the client
(`package/droiddeck-unconfirmed`; the app clears the count once the client is on screen), removes
the install stamp so the client is reinstalled. Counts from before this was tracked are dropped
rather than taken as failed starts. `droiddeck-steam-install` removes the repair request when it is
@@ -100,10 +100,10 @@ arm64 client down first.
- **FEX settings.** The app's PERFORMANCE_TSO preset (`core/FexPreset.kt`, WinNative's default). FEX's
own defaults keep half-barrier TSO and full-precision x87, which cost every x86 program time. Values
already in the environment win.
- **Fast path.** libblfastpath, preloaded into every guest process and so into FEX, broke FEX's 32-bit
- **Fast path.** libddfastpath, preloaded into every guest process and so into FEX, broke FEX's 32-bit
mode (SIGILL at start). It stands down when FEX is about to run a 32-bit program; 64-bit programs
keep it. `BL_X64_FP_OFF=1` turns it off for everything.
- **Diagnostics.** `BL_FEX` runs another FEX build (a `DEBUG_STRACE` one, say). `BL_FEXSERVER_LOG`
keep it. `DD_X64_FP_OFF=1` turns it off for everything.
- **Diagnostics.** `DD_FEX` runs another FEX build (a `DEBUG_STRACE` one, say). `DD_FEXSERVER_LOG`
starts a FEXServer in the foreground logging there; every FEX process that logs to "server"
(`FEX_OUTPUTLOG` or an AppConfig) then has its lines tagged with its pid (file logs overwrite each
other).
@@ -113,18 +113,18 @@ arm64 client down first.
The client's web helper draws its whole UI. There are two:
- **The arm64 client's helper** (`droiddeck-x64-arm-webhelper`), used when both clients are the same
Steam build (unless `BL_X64_X86_WEBHELPER=1`). FEX hands the arm64 program to the CPU, so it runs
Steam build (unless `DD_X64_X86_WEBHELPER=1`). FEX hands the arm64 program to the CPU, so it runs
natively with the session's preloads (KGSL poll fix, fast path) and the arm64 session's GPU
settings. It talks to the client over IPC, and a helper of another build never comes up: the client
restarted it every 10 s (device: 1790721607 against 1790904859). The session therefore updates the
arm64 client's parts on the same channel first (`droiddeck-steam-install --sync
steamdeck_publicbeta`). With this helper the client itself gets the GPU: it shows every Big Picture
frame the helper draws, and in software (llvmpipe under FEX) that held the UI at about 20 fps
(`BL_X64_CLIENT_SOFTWARE=1` keeps it in software). Device: 144 fps menus.
(`DD_X64_CLIENT_SOFTWARE=1` keeps it in software). Device: 144 fps menus.
- **The client's own x86 helper on the GPU** (`droiddeck-x64-webhelper`), otherwise: ANGLE's GL
backend through FEX's GL thunk to zink and Turnip. On ANGLE's Vulkan backend the x86 compositor
thread was the bottleneck (16 fps against 60). Never `--in-process-gpu`, the preload's default: a
GPU crash there took the whole helper down (102 restarts). `BL_X64_CEF_GPU=0` keeps it in software.
GPU crash there took the whole helper down (102 restarts). `DD_X64_CEF_GPU=0` keeps it in software.
Its GPU process loads libpci, which exits when `/sys/bus/pci/devices` lists a device whose files
the app may not read (a RedMagic's PCIe root ports): every GPU process exited with status 1 in about
50 ms, software ones too, until Chromium gave up ("GPU process isn't usable") and the menus stayed
@@ -132,7 +132,7 @@ The client's web helper draws its whole UI. There are two:
0 GPU process exits, ANGLE on zink and Turnip.
The session shim (`preload/net.c`) turns `steamrt64/steamwebhelper.sh`'s exec of `./steamwebhelper`
into `BL_X64_ARM_WEBHELPER`. Nothing in the client's folder is edited: the client checksums its files
into `DD_X64_ARM_WEBHELPER`. Nothing in the client's folder is edited: the client checksums its files
as it starts and reinstalled itself over an edited launcher (2-3 minutes) on every start.
Quick Access Menu and flicker, x86 helper:
@@ -149,7 +149,7 @@ Quick Access Menu and flicker, x86 helper:
`LIBGL_KOPPER_DISABLE=true` none did in 60 opens, at 60 fps instead of about 140 (Xwayland's
per-window timing for child windows). No flashes was chosen over frame rate.
Software path (no host thunks, or `BL_X64_SOFTWARE=1`): x86 Mesa has no driver for this GPU, so
Software path (no host thunks, or `DD_X64_SOFTWARE=1`): x86 Mesa has no driver for this GPU, so
llvmpipe for GL (the client's own window needs GLX) and the rootfs's own Vulkan ICDs (lavapipe). GLX
first failed because the desktop exports zink over the arm64 Turnip ICD; those variables are cleared.
`LIBGL_DRI3_DISABLE=1`: over DRI3 the X server hands out the GPU node and Mesa's software path then
@@ -187,7 +187,7 @@ alone would then read as an installed client.
0008). FEX opened every rootfs path with `openat2(RESOLVE_IN_ROOT)` and fell through to the arm64
guest on anything but EXDEV; x86 bash could not find libtinfo. Since r4 the fallback resolves the
path inside the rootfs itself (absolute symlinks restart at the rootfs, as `RESOLVE_IN_ROOT` does);
before, they resolved against the arm64 guest. `libblsession.so` (`preload/robust.c`) answers
before, they resolved against the arm64 guest. `libddsession.so` (`preload/robust.c`) answers
`openat2` first in practice and does the same walk for `RESOLVE_IN_ROOT` callers, so Valve's FEX-Emu
on the arm64 client gets it too. Each path component is then its own system call.
- `0002-thunkgen-newer-clang`: the container's newer clang has no `FileManager::clearStatCache()`,
@@ -214,7 +214,7 @@ alone would then read as an installed client.
- **Where the app gets it.** The app downloads FEX from Droid-Deck/DroidDeck-Components, where nothing is
uploaded by hand. The app follows its `fex.json`: it reads it from
Components' `main` (directly, at most every ten minutes) and keeps the last copy, and every session passes
that build to `droiddeck-fex-update` (`BL_FEX_TAG`, `BL_FEX_SHA256`, `BL_FEX_URLS` with the download
that build to `droiddeck-fex-update` (`DD_FEX_TAG`, `DD_FEX_SHA256`, `DD_FEX_URLS` with the download
source's mirrors). The script installs a build only after its archive matches the sha256 and every
program in it loads (`ld-linux --list`); the files it replaces are kept aside until the installed copy
loads too and put back otherwise, and the tag is written last. Otherwise it keeps the installed one while that still loads,
@@ -246,7 +246,7 @@ alone would then read as an installed client.
- **Mapping** (`x64_map_direct`): every game the client's appinfo cache shows with a Linux build (type
game, oslist with linux; runtime from `config/app_mappings`: SteamLinuxRuntime_sniper or _soldier,
none means scout), installed or not, so Steam downloads the Linux depots. A title on a tool chosen in
Properties keeps it, except `BL_X64_DIRECT_APPS` (Left 4 Dead 2, 550, by default), which is always
Properties keeps it, except `DD_X64_DIRECT_APPS` (Left 4 Dead 2, 550, by default), which is always
taken back. `direct-auto.json` lists what was mapped. One pass over the mapping: a 2000-title fixture
went from 16.5 s to 0.2 s with the same output.
- A game whose Windows build is installed (it ran on a Proton before) stays a Windows game on the
@@ -270,7 +270,7 @@ alone would then read as an installed client.
in its container.
- **GPU.** Games get FEX's host thunks and the session's GPU settings (Turnip, Zink), saved by the
launcher as `game-gpu.env` and rewritten whenever it runs; `game-gpu.local` is the user's, never
rewritten, and is read after it. `BL_X64_GAME_SOFTWARE=1` keeps a game in software, with
rewritten, and is read after it. `DD_X64_GAME_SOFTWARE=1` keeps a game in software, with
`mesa_glthread=false` (GL threading is no help with software GL under FEX).
- Source games (`hl2.sh`, `hl2_linux`, `srcds`) get `-condebug` for the VAC diagnostics.
- **Controllers.** `libfakeinput` is built for x86-64 and preloaded in the rootfs; Big Picture works
@@ -316,7 +316,7 @@ alone would then read as an installed client.
written only while no client runs. Shader pre-caching stays each client's own: the x86 client may
fetch a shared game's shader cache into its own folder (Valheim, 1.8 GB).
- **SD card.** The x86 client's card library is a folder inside the arm64 one (`/mnt/droiddeck-sd/x86-64`,
`GameStorage.X64_CARD_DIR`, passed as `BL_X64_STEAM_LIBRARIES`), so the install dialog offers Internal
`GameStorage.X64_CARD_DIR`, passed as `DD_X64_STEAM_LIBRARIES`), so the install dialog offers Internal
Storage and SD card. compatdata, shadercache and runtime tools stay private, as in the arm64 card
library. FEX runs x86 programs from the noexec exFAT card. The folder appears with the client's first
session on the card and its `steamapps` with the first library write. Desktop sessions prepare it as
@@ -378,7 +378,7 @@ alone would then read as an installed client.
it. It keeps the game display Steam chose: the saved `DISPLAY=:0` hid the game window and made
DiRT Showdown exit after about 7 s. Proton takes its Steam client parts from the client's install
folder, and the x86 client's are x86, so `STEAM_COMPAT_CLIENT_INSTALL_PATH` points at the arm64 root
and `BL_X64_STEAM_ROOT` keeps the x86 one for install-script lookups.
and `DD_X64_STEAM_ROOT` keeps the x86 one for install-script lookups.
- **Game overlay.** The x86 client preloads its own x86 overlay; the arm64 one takes its place. The
overlay marks the game's windows with the Steam app ID, and without it gamescope never shows them
(FlatOut ran and played sound behind Steam's launch screen, "steam app id: 0"). The agent also tags
@@ -425,7 +425,7 @@ alone would then read as an installed client.
to secure servers."). That console reaches a file only with `-condebug`: `<game>/<mod>/console.log`,
or `<game>/game/<mod>/console.log` for Source 2. At session start the app writes
`~/.droiddeck-vac-diagnostics` (start time, client, each console.log's length, since `-condebug`
appends). The launch wrapper (`bl_vacdiag`) then adds `-condebug` to Source titles (found by
appends). The launch wrapper (`dd_vacdiag`) then adds `-condebug` to Source titles (found by
`gameinfo.txt` or `gameinfo.gi`), flags `-insecure` in launch options and notes each launch. At the
end the session copies what each console.log gained into `vac/`, scrubbed, and writes `vac.txt`: the
game's secure/insecure lines, VAC lines in the client's logs, and which client files are present. A
@@ -440,7 +440,7 @@ alone would then read as an installed client.
## Session integration, restarts and mapping
- With `BL_STEAM_CLIENT_ARCH=x86_64`, `droiddeck-session` updates the arm64 client's parts
- With `DD_STEAM_CLIENT_ARCH=x86_64`, `droiddeck-session` updates the arm64 client's parts
(`droiddeck-steam-install`, then `--sync steamdeck_publicbeta`), runs `droiddeck-steam-x64 --prepare`
and starts the client with `droiddeck-steam-x64 --exec`. Steps only for the arm64 client (library
registration, the ARM64 Proton fetch, the live compat helper) are skipped; added games,
@@ -450,7 +450,7 @@ alone would then read as an installed client.
failed at ../src/pulse/operation.c:136 pa_operation_get_state()", the runtime's PulseAudio 13).
`preload/pulseguard.c` (x86 builds only; the arm64 client does not hit it) answers a missing operation
as cancelled and ignores its unref and cancel. The session passes `-steamdeck -steamos3` unless
`BL_X64_DECK=0`. Switch to Desktop is expected to need no change (an x86 shell under FEX runs
`DD_X64_DECK=0`. Switch to Desktop is expected to need no change (an x86 shell under FEX runs
`steamos-session-select`); the full switch has not been tested on a device.
- **Process names.** Under FEX a process's argv[0] is FEX and the program is its first argument. The
session's game detection, CPU pinning and the zRAM watcher read that argument. Steam pins itself and
@@ -459,13 +459,13 @@ alone would then read as an installed client.
`steam-compatibility --x64 --live` and `droiddeck-steam-x64 --map-direct --live`, every 15 s and
only in the session's first hour (720 beats of 5 s). A title installed after that is mapped when the
client exits and takes effect from the next session. Steam reads a
mapping changed while it runs only at its next start, so changed titles go to `.bl-compat-pending`.
mapping changed while it runs only at its next start, so changed titles go to `.dd-compat-pending`.
Once they have installed (`StateFlags` 4 in the client's root or its card folder) and no game runs,
the client is restarted once per title, at most 3 times a session.
- **After exit.** Added games, `steam-compatibility --x64` and `--map-direct` run again: the client
wrote its mapping from memory as it exited, over what the live passes set.
- The Lossless Scaling ownership probe and the Steam import watcher reach the x86 client through the
arm64 client's `steamclient.so` (`BL_STEAMCLIENT`); the watcher restarts the client with
arm64 client's `steamclient.so` (`DD_STEAMCLIENT`); the watcher restarts the client with
`droiddeck-steam-x64 --exec -shutdown`.
- Steam logs and the Steam language come from the x86 client's home. On the desktop, `steam` and
`steamdeck-steam` start the selected client, and the desktop game entries list its libraries.