mirror of
https://github.com/Droid-Deck/DroidDeck.git
synced 2026-11-20 21:35:59 +00:00
Merge remote-tracking branch 'origin/main' into fix/steam-sd-preallocation
This commit is contained in:
commit
0d1d47e8b0
173 files changed
+15896
-9674
No files matched your search
+46
-6
@@ -39,9 +39,9 @@ for tool in curl tar zstd shasum unzip; do
|
||||
exit 1
|
||||
fi
|
||||
done
|
||||
if [[ -f "${repo_root}/tools/gamescope/release.env" || -f "${repo_root}/tools/wlroots/release.env" ]] \
|
||||
&& ! command -v gh >/dev/null 2>&1; then
|
||||
echo "GitHub CLI is required to download the pinned Gamescope and wlroots release assets." >&2
|
||||
if [[ -f "${repo_root}/tools/gamescope/release.env" || -f "${repo_root}/tools/wlroots/release.env" \
|
||||
|| -f "${repo_root}/tools/droiddeck-esync/release.env" ]] && ! command -v gh >/dev/null 2>&1; then
|
||||
echo "GitHub CLI is required to download the pinned Gamescope, wlroots and droiddeck-esync release assets." >&2
|
||||
exit 1
|
||||
fi
|
||||
|
||||
@@ -129,7 +129,7 @@ docker run --rm --platform linux/amd64 \
|
||||
mkdir -p "$d/usr/local/bin"
|
||||
aarch64-linux-gnu-gcc -O2 -Wall -Wextra -o "$d/usr/local/bin/droiddeck-clipboard" tools/linuxfs/clipboard/clipboard.c -ldl
|
||||
aarch64-linux-gnu-strip --strip-unneeded "$d/usr/local/bin/droiddeck-clipboard"
|
||||
for script in tools/linuxfs/overlay/usr/local/bin/bannerlator-*; do
|
||||
for script in tools/linuxfs/overlay/usr/local/bin/droiddeck-* tools/linuxfs/overlay/usr/local/bin/steam-compatibility; do
|
||||
install -Dm644 "$script" "$d/usr/local/bin/$(basename "$script")"
|
||||
done
|
||||
for f in tools/linuxfs/overlay/usr/bin/* tools/linuxfs/overlay/usr/bin/steamos-polkit-helpers/*; do
|
||||
@@ -166,8 +166,18 @@ docker run --rm --platform linux/amd64 \
|
||||
exit 1
|
||||
}
|
||||
done
|
||||
test -f "$d/usr/local/bin/bannerlator-session"
|
||||
test -f "$d/usr/local/bin/bannerlator-proton-extra"
|
||||
test -f "$d/usr/local/bin/droiddeck-session"
|
||||
test -f "$d/usr/local/bin/droiddeck-proton-extra"
|
||||
'
|
||||
|
||||
docker run --rm --platform linux/amd64 \
|
||||
-v "${repo_root}:/src" -w /src debian:bullseye bash -c '
|
||||
set -euo pipefail
|
||||
printf "deb http://archive.debian.org/debian bullseye main\ndeb http://archive.debian.org/debian-security bullseye-security main\n" > /etc/apt/sources.list
|
||||
apt-get -o Acquire::Check-Valid-Until=false update -qq
|
||||
DEBIAN_FRONTEND=noninteractive apt-get install -y -qq --no-install-recommends gcc g++ gcc-multilib g++-multilib binutils >/dev/null
|
||||
tools/linuxfs/build-x86-preloads.sh app/src/main/assets/linuxfs
|
||||
chown -R '"$(id -u):$(id -g)"' app/src/main/assets/linuxfs
|
||||
'
|
||||
|
||||
github_repo=${DROIDDECK_GITHUB_REPOSITORY:-}
|
||||
@@ -223,6 +233,36 @@ if [[ -f "${repo_root}/tools/wlroots/release.env" ]]; then
|
||||
test -f "${linuxfs_dir}/usr/local/lib/droiddeck-wlroots/libwlroots-0.20.so"
|
||||
fi
|
||||
|
||||
. "${repo_root}/tools/linuxfs/uruntime.env"
|
||||
uruntime_binary=$(cached "${URUNTIME_SHA256}" "${URUNTIME_ASSET}" \
|
||||
bash -c 'curl -fsSL --retry 3 -o "$out" "$0"' "https://github.com/VHSgunzo/uruntime/releases/download/${URUNTIME_VERSION}/${URUNTIME_ASSET}")
|
||||
install -Dm644 "${uruntime_binary}" "${linuxfs_dir}/usr/local/lib/droiddeck/uruntime"
|
||||
install -Dm644 "${repo_root}/tools/linuxfs/licenses/uruntime-LICENSE" "${linuxfs_dir}/usr/local/share/licenses/uruntime/LICENSE"
|
||||
|
||||
sync_assets="${repo_root}/app/src/main/assets/droiddeck-esync"
|
||||
if [[ -f "${repo_root}/tools/droiddeck-esync/release.env" ]]; then
|
||||
. "${repo_root}/tools/droiddeck-esync/release.env"
|
||||
sync_archive=$(cached "${SYNC_BUNDLE_SHA256}" "${SYNC_BUNDLE_ASSET}" \
|
||||
bash -c 'gh release download "$0" -R "$2" -p "$1" -O "$out"' "${SYNC_BUNDLE_TAG}" "${SYNC_BUNDLE_ASSET}" "${SYNC_BUNDLE_REPO}")
|
||||
rm -rf "${sync_assets}"
|
||||
mkdir -p "${sync_assets}"
|
||||
zstd -dc "${sync_archive}" | tar -xf - -C "${sync_assets}"
|
||||
test -f "${sync_assets}/index.json"
|
||||
test -f "${sync_assets}/index.json.sig"
|
||||
sync_index=$(mktemp)
|
||||
gh release download "${SYNC_BUNDLE_TAG}" -R "${SYNC_BUNDLE_REPO}" -p index.json -O "${sync_index}" --clobber
|
||||
revoked=$(python3 -c 'import json, sys; print(" ".join(p["id"] for p in json.load(open(sys.argv[1]))["packs"] if p.get("revoked") is True))' "${sync_index}")
|
||||
for id in ${revoked}; do
|
||||
if [[ -e "${sync_assets}/packs/${id}.tzst" ]]; then
|
||||
echo "${SYNC_BUNDLE_ASSET} carries revoked pack ${id}; it is left out of the APK" >&2
|
||||
rm -f "${sync_assets}/packs/${id}.tzst"
|
||||
fi
|
||||
done
|
||||
rm -f "${sync_index}"
|
||||
elif [[ -d "${sync_assets}" ]]; then
|
||||
echo "No tools/droiddeck-esync/release.env: the APK bundles the droiddeck-esync packs already in ${sync_assets}." >&2
|
||||
fi
|
||||
|
||||
mango_dir="${linuxfs_dir}/usr/local/lib/mangoapp"
|
||||
mango_pkgs="${staging_dir}/mango-pkgs"
|
||||
mkdir -p "${mango_dir}" "${mango_pkgs}"
|
||||
|
||||
@@ -1,170 +0,0 @@
|
||||
# droiddeck-esync packs
|
||||
|
||||
DroidDeck gives Proton three in-process sync backends, picked with the Wine sync tabs in the
|
||||
Steam settings' Games group: ntsync, fsync (the default), esync and wineserver. The wineserver tab
|
||||
sets `PROTON_NO_ESYNC=1`, `PROTON_NO_FSYNC=1` and `PROTON_NO_NTSYNC=1` (unless a game's own
|
||||
environment sets them), so every sync object goes through the server.
|
||||
|
||||
- droiddeck-esync: eventfd and shared memory sync. Stock Wine 11 / Proton 11 builds
|
||||
have no eventfd-based sync, so the patch series under `patches/<series>` adds it to wineserver
|
||||
and the unix side of ntdll. A Proton build without a pack (a release newer than the published
|
||||
packs, or one whose pack failed to install) runs stock with droiddeck-fsync standing in, or
|
||||
droiddeck-ntsync where fsync is off for the game (`PROTON_NO_FSYNC=1`, or one of the games
|
||||
Proton itself keeps off fsync and esync), so it still gets in-process sync; `PROTON_NO_NTSYNC=1`
|
||||
as well leaves it on wineserver-only sync. A Proton with esync built in (GE, cachyos) runs its
|
||||
own esync, and a game that turns esync off moves to droiddeck-fsync or droiddeck-ntsync there
|
||||
too.
|
||||
- droiddeck-fsync: Proton's own fsync on the stock binaries. fsync waits with `futex_waitv(2)`,
|
||||
which the app sandbox refuses, so `libblsession.so` (`BL_FSYNC=1`) answers that system call in
|
||||
userspace: every waiter registers the futexes it waits on in a shared table next to the fsync
|
||||
shared memory and sleeps on a futex of its own, and every `FUTEX_WAKE` on the fsync shared memory
|
||||
wakes the waiters registered on that word. No pack is involved, so it keeps working the moment
|
||||
Steam updates Proton. It is the default (the fsync tab, `BL_FSYNC_FIRST=1`, also per game),
|
||||
ahead of droiddeck-esync; on the esync tab it stands in where no pack fits, and it also takes
|
||||
over for a game whose environment turns esync off (`PROTON_NO_ESYNC=1`, `WINEESYNC=0`, or too
|
||||
few file descriptors); where fsync is off as well, such a game gets droiddeck-ntsync, with the
|
||||
pack's wineserver when a pack fits. A launch into a prefix whose wineserver is still running
|
||||
keeps the sync choice that server was started with (`prefixes.json` in the store), because a
|
||||
Wine client that disagrees with its server about fsync exits. It inherits stock fsync's behaviour, the same as on a Linux kernel:
|
||||
a wait-all on a mutex abandoned by a dead thread is not satisfied, a pending user APC is
|
||||
delivered ahead of an object that is already signaled, a mutex owned by a process killed with
|
||||
`TerminateProcess` is not abandoned, and `PulseEvent` can miss a waiter that has not run yet.
|
||||
- droiddeck-ntsync: a userspace implementation of the `/dev/ntsync` interface in
|
||||
`libblsession.so` (`BL_SYNC=1`), which stock Proton 11 builds use as they would the kernel
|
||||
driver. It is the ntsync tab. A pack still supplies the binaries when one fits, and its
|
||||
wineserver then picks ntsync over esync; a Proton whose wineserver has no ntsync client (no
|
||||
`/dev/ntsync` in it) gets droiddeck-fsync instead.
|
||||
|
||||
wineserver picks the backend at startup: `PROTON_NO_NTSYNC` unset -> `/dev/ntsync`
|
||||
(droiddeck-ntsync, or a kernel driver the device provides) -> fsync (droiddeck-fsync, or a kernel
|
||||
and sandbox that allow `futex_waitv`) -> droiddeck-esync (needs `WINEESYNC` nonzero) ->
|
||||
server-side sync. When a pack is in use and droiddeck-esync is on, the guest's `droiddeck-esync`
|
||||
script also sets `PROTON_NO_FSYNC=1` unless the game's environment sets it, so droiddeck-esync
|
||||
comes before fsync unless droiddeck-fsync was chosen. A wineserver from a pack reports the
|
||||
backend on stderr as `droiddeck-ntsync: up and running.` or `droiddeck-esync: up and running.`;
|
||||
with droiddeck-fsync the stock wineserver prints `fsync: up and running.` after
|
||||
`droiddeck-fsync: up and running.`. A pack's wineserver also abandons, when a process dies, every
|
||||
mutex still owned by one of its threads, and, once a thread killed by `TerminateThread` has really
|
||||
exited, every mutex it still owns. A killed thread keeps running until the kill signal reaches it
|
||||
and can take a mutex after the server abandoned its mutexes; without these passes that mutex would
|
||||
stay locked for good (they cover droiddeck-ntsync and kernel ntsync as well). The ntdll side
|
||||
reads, writes and polls its eventfds with raw system calls, so no `LD_PRELOAD` wrapper of
|
||||
`read`/`write`/`poll` (the guest preloads several) sits in the sync path or in the unwind of a
|
||||
thread Wine kills.
|
||||
|
||||
The patch changes no wineserver request: `make_pack.py` refuses a build whose
|
||||
`server_protocol.h`, `request_handlers.h` or `request_trace.h` differ from the unpatched
|
||||
control build, or whose ntdll.so exports other symbols. Only `files/lib/wine/aarch64-unix/ntdll.so`
|
||||
and `files/bin-arm64/wineserver` are replaced, so every Proton build needs its own pair, built
|
||||
from that build's exact wine source. That pair plus `pack.json` is a pack (`<id>.tzst`). On the
|
||||
device the guest runs Proton from a shadow tree that links the stock tool and holds the two
|
||||
patched files (`droiddeck-esync`, store in `~/.local/share/droiddeck-esync`).
|
||||
|
||||
## Credits
|
||||
|
||||
droiddeck-esync follows the esync design and droiddeck-ntsync implements the ntsync interface;
|
||||
both are the work of Elizabeth Figura for Wine, Proton and the Linux kernel. droiddeck-fsync runs
|
||||
fsync, by Elizabeth Figura and Paul Gofman for Proton, over `futex_waitv(2)` by André Almeida.
|
||||
DroidDeck builds on that work for Android, where neither the ntsync driver, `futex_waitv` nor a
|
||||
Proton build with esync is available.
|
||||
|
||||
## Matching
|
||||
|
||||
- `ge`, `cachyos`: built against the release tarball's own binaries. `pack.json` `stock` holds
|
||||
their sha256; the guest uses the pack only when both files hash the same. `make_pack.py` also
|
||||
requires the control build to reproduce both files byte for byte, so the patched pair differs
|
||||
from the release only by the patch (`--allow-unreproduced` lifts this for local experiments).
|
||||
- `valve`: the depots cannot be downloaded without a Steam login, so `stock` holds the control
|
||||
build's hashes and `source_match` is true: the guest also accepts a tool whose version token
|
||||
(second field of `<tool>/version`) and ntdll.so exports hash equal the pack's. With the optional
|
||||
`STEAM_DEPOT_USER` / `STEAM_DEPOT_TOKEN` secrets (and the `DEPOT_DOWNLOADER_SHA256` variable)
|
||||
the job downloads the depot instead and, when the depot is at the tag being built, makes an
|
||||
exact pack. The guest's launch line says which kind matched (`exact match` or `source match`).
|
||||
- A stock wineserver that already has esync built in (it prints `esync: up and running`) never
|
||||
gets a pack.
|
||||
|
||||
## Building and publishing
|
||||
|
||||
`.github/workflows/watch-proton-releases.yml` runs every 20 minutes and decides when a build is
|
||||
due. It asks Steam anonymously (`steamcmd +app_info_print`) which public build of each Valve ARM64
|
||||
depot app in `flavors.json` is live, and `discover.py watch` compares that, the newest `keep` tags
|
||||
and releases of every flavor, each flavor's `rev` and its patch series digest with the state of the
|
||||
last run (`watch-state.json` in the `droiddeck-esync-index` release). A flavor whose builds, rev or
|
||||
patch series changed, or whose Steam build moved, starts
|
||||
`.github/workflows/build-droiddeck-esync-packs.yml` for that flavor; nothing else starts a build.
|
||||
A run that finds no change takes about a minute and builds nothing. If steamcmd fails, the run
|
||||
watches the tags only and keeps the last Steam state.
|
||||
|
||||
`.github/workflows/build-droiddeck-esync-packs.yml` also runs once a day as a safety net, on pushes
|
||||
to `tools/droiddeck-esync/**` and by hand (flavor, one tag, publish yes/no). Only runs on `main` of
|
||||
`Droid-Deck/DroidDeck` publish packs; the schedule and pushes do nothing in other repositories,
|
||||
and manual runs elsewhere only build.
|
||||
|
||||
1. `discover.py matrix` lists the newest `keep` builds of each family in `flavors.json` (Valve
|
||||
tags, GE and CachyOS releases with an arm64 tarball) and drops the ones the published index,
|
||||
or the `droiddeck-esync-<flavor>` release, already has at the flavor's `rev`, the ones
|
||||
`revoked.txt` names, and the ones that failed in the last day at the same `rev` and patch
|
||||
series (a `<key>-r<rev>-<series digest>.failed` asset in the flavor's release). Naming the tag
|
||||
in a manual run builds it anyway.
|
||||
2. Each build runs on an arm64 runner with a read-only token, since it runs upstream code: the
|
||||
wine source is checked out at the tag (GE also runs its `protonprep-valve-staging.sh`),
|
||||
`build-pack.sh` builds a control and a patched pair inside the SDK image named by the
|
||||
source's own `Makefile.in` (arm64-llvm), at the flavor's `build_dir` in `flavors.json` (the
|
||||
path the release itself was built at, which ends up in the binaries), and `make_pack.py` makes
|
||||
the pack. Patches apply with `--fuzz=0`: a hunk whose context moved fails the build instead of
|
||||
landing somewhere else. For GE and CachyOS, whose release tarball holds the whole Proton,
|
||||
`smoke-test.sh` then boots a prefix with that stock Proton and runs `tests/esstress.c` (built
|
||||
with the SDK's llvm-mingw) under server-side sync as a baseline, and again with the pack under
|
||||
droiddeck-esync. A pack that fails while stock passes is not published; when stock itself cannot
|
||||
run on the runner the step only warns.
|
||||
3. The publish job checks each build's artifact against the matrix (`discover.py packs`) and
|
||||
uploads it to the `droiddeck-esync-valve`, `droiddeck-esync-ge` or `droiddeck-esync-cachyos`
|
||||
release as `<id>.tzst` with its index entry `<id>.json`. A build that made no pack gets its
|
||||
`.failed` marker there (`discover.py failures`), so a patch that does not apply or a stock
|
||||
wineserver with esync built in is not rebuilt on every run.
|
||||
4. The index job (environment `droiddeck-esync-signing`) runs only when the run built a pack or
|
||||
a published pack is not in the index yet. It collects every `<id>.json`, keeps the
|
||||
highest `rev` per stock pair and version, marks revoked ids, signs `index.json` (ECDSA P-256,
|
||||
`index-key.pub`) and publishes `bundle-<YYYYMMDD>-<HHMMSS>.tzst` (named after `generated`, so
|
||||
every signed index has its own), `index.json` and `index.json.sig` to `droiddeck-esync-index`.
|
||||
`generated` only grows. Packs stay in the index until they are revoked, also when their
|
||||
entry asset disappears; the previous index counts only when its signature verifies.
|
||||
|
||||
A pack is rebuilt only for a new `rev`: bump `rev` of the flavor in `flavors.json` whenever the
|
||||
patch series or the build changes. Local builds: `BUILD_DIR=<the flavor's build_dir> SYNC_PROFILE=<the
|
||||
flavor's profile> build-local.sh <sdk-rootfs> <wine-source> <work-dir> <out-dir> [patch-dir]`,
|
||||
then `make_pack.py`.
|
||||
|
||||
## Setup
|
||||
|
||||
- Signing key: create the repository environment `droiddeck-esync-signing` (Settings ->
|
||||
Environments, limit it to `main`) and store the PEM private key as its secret
|
||||
`SYNC_INDEX_KEY`: `gh secret set SYNC_INDEX_KEY --env droiddeck-esync-signing < index-key.pem`.
|
||||
The key never enters the repository; the app trusts only `index-key.pub` (also compiled into
|
||||
`EsyncPacks.kt`), so a new key needs an app release.
|
||||
- Optional: `STEAM_DEPOT_USER` and `STEAM_DEPOT_TOKEN` repository secrets for exact Valve packs,
|
||||
plus the repository variable `DEPOT_DOWNLOADER_SHA256`: the sha256 of
|
||||
`DepotDownloader-linux-arm64.zip` from the DepotDownloader release the workflow pins
|
||||
(`DEPOT_DOWNLOADER_TAG`). The depot step is skipped while it is unset.
|
||||
- APK bundle: after an index run, the job summary prints three lines. Put them in
|
||||
`tools/droiddeck-esync/release.env`:
|
||||
|
||||
```
|
||||
SYNC_BUNDLE_TAG=droiddeck-esync-index
|
||||
SYNC_BUNDLE_ASSET=bundle-20261002-061733.tzst
|
||||
SYNC_BUNDLE_SHA256=<sha256>
|
||||
```
|
||||
|
||||
`build.yml` then unpacks that bundle into `app/src/main/assets/droiddeck-esync/` (gitignored). A
|
||||
published bundle is never overwritten, so the pinned sha256 stays valid; bump `release.env`
|
||||
to ship newer packs inside the apk. The app fetches newer packs on its own. A pack the bundle
|
||||
carries that `revoked.txt` names is left out of the apk, with a warning to bump `release.env`.
|
||||
|
||||
## Revocation
|
||||
|
||||
Add the pack id as the first word of a line in `revoked.txt` and push to `main`. The workflow
|
||||
re-signs the index with `"revoked": true` for that id; the app deletes installed copies and
|
||||
never installs it again, and `discover.py` does not rebuild it at the same `rev`. The apk build
|
||||
also leaves it out of the bundled packs. To ship a fixed pack for the same Proton build, bump the
|
||||
flavor's `rev`. Runs that only build (other refs, or manual runs without publish) never queue in
|
||||
front of a publishing run, so a revocation is signed by the next run on `main`.
|
||||
@@ -1,27 +0,0 @@
|
||||
#!/bin/bash
|
||||
set -euo pipefail
|
||||
|
||||
if [ $# -lt 4 ]; then
|
||||
echo "usage: $0 <sdk-rootfs> <wine-source> <work-dir> <out-dir> [patch-dir]" >&2
|
||||
echo "env: BUILD_DIR (path the build runs at inside the SDK), SYNC_PROFILE (valve or cachyos), JOBS, SOURCE_DATE_EPOCH" >&2
|
||||
exit 2
|
||||
fi
|
||||
here=$(cd "$(dirname "$0")" && pwd)
|
||||
sdk=$(realpath "$1")
|
||||
src=$(realpath "$2")
|
||||
work=$(realpath -m "$3")
|
||||
out=$(realpath -m "$4")
|
||||
patches=${5:+$(realpath "$5")}
|
||||
build_dir=${BUILD_DIR:-/builds/proton/proton/build-dir}
|
||||
rm -rf "$work"
|
||||
mkdir -p "$work" "$out"
|
||||
"$here/build-pack.sh" prepare "$src" "$work" ${patches:+"$patches"}
|
||||
bwrap --unshare-user --uid 0 --gid 0 --unshare-ipc --unshare-pid \
|
||||
--bind "$sdk" / --proc /proc --dev /dev --tmpfs /tmp \
|
||||
--bind "$work" "$build_dir" --bind "$out" /out --ro-bind "$here/build-pack.sh" /build-pack.sh \
|
||||
--setenv PATH /opt/llvm-mingw/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin \
|
||||
--setenv HOME /tmp --setenv LANG C.UTF-8 --setenv JOBS "${JOBS:-$(nproc)}" \
|
||||
--setenv SOURCE_DATE_EPOCH "${SOURCE_DATE_EPOCH:-1700000000}" --setenv SYNC_PROFILE "${SYNC_PROFILE:-valve}" \
|
||||
--chdir "$build_dir" \
|
||||
/bin/bash /build-pack.sh build "$build_dir" /out
|
||||
sha256sum "$out/files/lib/wine/aarch64-unix/ntdll.so" "$out/files/bin-arm64/wineserver"
|
||||
@@ -1,125 +0,0 @@
|
||||
#!/bin/bash
|
||||
set -euo pipefail
|
||||
|
||||
usage() {
|
||||
echo "usage: $0 prepare <wine-source> <build-dir> [patch-dir]" >&2
|
||||
echo " $0 build <build-dir> <out-dir>" >&2
|
||||
echo " $0 all <wine-source> <out-dir> [patch-dir]" >&2
|
||||
exit 2
|
||||
}
|
||||
|
||||
prepare() {
|
||||
local origin=$1 b=$2 patches=${3:-}
|
||||
local s=$b/src-wine
|
||||
mkdir -p "$s"
|
||||
rsync --filter=:C --exclude '*~' --exclude .git --exclude compile_commands.json \
|
||||
--exclude configure --exclude autom4te.cache --exclude include/config.h.in --exclude include/config.h.ink \
|
||||
--exclude include/wine/vulkan.h --exclude dlls/vulkan-1/vulkan-1.spec \
|
||||
--exclude dlls/winevulkan/loader_thunks.c --exclude dlls/winevulkan/loader_thunks.h \
|
||||
--exclude dlls/winevulkan/vulkan_thunks.c --exclude dlls/winevulkan/vulkan_thunks.h \
|
||||
--exclude dlls/winevulkan/winevulkan.json --exclude dlls/winevulkan/winevulkan.spec \
|
||||
--exclude dlls/ntdll/ntsyscalls.h --exclude dlls/win32u/win32syscalls.h \
|
||||
--exclude include/wine/server_protocol.h --exclude server/request_handlers.h --exclude server/request_trace.h \
|
||||
-Oarx --delete "$origin/" "$s/"
|
||||
for f in include/wine/server_protocol.h server/request_handlers.h server/request_trace.h; do
|
||||
cp -a "$origin/$f" "$s/$f"
|
||||
done
|
||||
if [ -n "$patches" ]; then
|
||||
local p found=0
|
||||
for p in "$patches"/*.patch; do
|
||||
[ -f "$p" ] || continue
|
||||
patch -d "$s" -p1 --forward --fuzz=0 --no-backup-if-mismatch -s < "$p"
|
||||
found=1
|
||||
done
|
||||
[ "$found" = 1 ] || { echo "no patches in $patches" >&2; exit 1; }
|
||||
fi
|
||||
(
|
||||
cd "$s"
|
||||
XDG_CACHE_HOME=$b/cache dlls/winevulkan/make_vulkan -x vk.xml -X video.xml
|
||||
tools/make_specfiles || true
|
||||
tools/make_requests
|
||||
) > "$b/generate.log" 2>&1
|
||||
touch "$b/.prepared"
|
||||
}
|
||||
|
||||
build() {
|
||||
local b=$1 out=$2
|
||||
local s=$b/src-wine o=$b/obj-wine-aarch64 d=$b/dst-wine-aarch64
|
||||
[ -f "$b/.prepared" ] || { echo "$b is not prepared" >&2; exit 1; }
|
||||
local jobs=${JOBS:-$(nproc)}
|
||||
local epoch=$(( ${SOURCE_DATE_EPOCH:-1700000000} - 20 ))
|
||||
local flags args pe_common i386_flags x86_64_flags conf
|
||||
case ${SYNC_PROFILE:-valve} in
|
||||
valve)
|
||||
flags="-Wno-discarded-qualifiers -march=armv8.2-a -mtune=cortex-x3 -O2 -fwrapv -fno-strict-aliasing -ggdb -ffunction-sections -fdata-sections -fno-omit-frame-pointer -ffile-prefix-map=$s=."
|
||||
args=(--enable-werror --with-mingw=clang --disable-tests --enable-archs=arm64ec,aarch64,i386,x86_64)
|
||||
pe_common="-O2 -fwrapv -fno-strict-aliasing -ggdb -ffunction-sections -fdata-sections -fno-omit-frame-pointer -ffile-prefix-map=$s=."
|
||||
i386_flags="-Wno-discarded-qualifiers -mstackrealign -march=nocona -mtune=core-avx2 -mfpmath=sse $pe_common"
|
||||
x86_64_flags="-Wno-discarded-qualifiers -mcmodel=small -march=nocona -mtune=core-avx2 -mfpmath=sse $pe_common"
|
||||
conf="../$(basename "$s")/configure"
|
||||
;;
|
||||
cachyos)
|
||||
flags="-Wno-discarded-qualifiers -Wno-stringop-overflow -Wno-incompatible-pointer-types -O2 -march=armv8.2-a -mtune=cortex-x3 -fwrapv -fno-strict-aliasing -ffunction-sections -fdata-sections -fno-omit-frame-pointer -ffile-prefix-map=$s=."
|
||||
args=(--with-mingw=clang --enable-build-id --disable-tests --enable-archs=arm64ec,aarch64,i386,x86_64)
|
||||
pe_common="-fwrapv -fno-strict-aliasing -ffunction-sections -fdata-sections -fno-omit-frame-pointer -ffile-prefix-map=$s=."
|
||||
i386_flags="-Wno-discarded-qualifiers -Wno-stringop-overflow -Wno-incompatible-pointer-types -mstackrealign -O2 -march=nocona -mtune=core-avx2 -pipe -mfpmath=sse $pe_common"
|
||||
x86_64_flags="-Wno-discarded-qualifiers -Wno-stringop-overflow -Wno-incompatible-pointer-types -mcmodel=small -O2 -march=nocona -mtune=core-avx2 -pipe -mfpmath=sse $pe_common"
|
||||
conf="$s/configure"
|
||||
;;
|
||||
*)
|
||||
echo "unknown SYNC_PROFILE ${SYNC_PROFILE}" >&2
|
||||
exit 2
|
||||
;;
|
||||
esac
|
||||
local env=(STRIP=llvm-strip AR=aarch64-linux-gnu-ar RANLIB=aarch64-linux-gnu-ranlib
|
||||
CC=aarch64-linux-gnu-gcc CXX=aarch64-linux-gnu-g++ LD=aarch64-linux-gnu-ld
|
||||
RC=aarch64-w64-mingw32-windres WIDL=aarch64-w64-mingw32-widl PKG_CONFIG=aarch64-linux-gnu-pkg-config
|
||||
"PKG_CONFIG_LIBDIR=/usr/lib/aarch64-linux-gnu/pkgconfig:/usr/share/pkgconfig"
|
||||
"CFLAGS=$flags" "CPPFLAGS=$flags" "CXXFLAGS=-std=c++17 $flags" "LDFLAGS=" "SOURCE_DATE_EPOCH=$epoch"
|
||||
"CROSSCFLAGS=$flags" "CROSSLDFLAGS="
|
||||
"aarch64_CFLAGS=$flags" "aarch64_CPPFLAGS=$flags" "aarch64_CXXFLAGS=-std=c++17 $flags" "aarch64_LDFLAGS="
|
||||
i386_AR=i686-w64-mingw32-ar i386_RANLIB=i686-w64-mingw32-ranlib i386_CC=i686-w64-mingw32-gcc
|
||||
i386_CXX=i686-w64-mingw32-g++ i386_LD=i686-w64-mingw32-ld
|
||||
"i386_CFLAGS=$i386_flags" "i386_CPPFLAGS=$i386_flags" "i386_CXXFLAGS=-std=c++17 $i386_flags" "i386_LDFLAGS="
|
||||
"i386_PKG_CONFIG_LIBDIR=/usr/lib/i386-w64-mingw32/pkgconfig:/usr/share/pkgconfig"
|
||||
x86_64_AR=x86_64-w64-mingw32-ar x86_64_RANLIB=x86_64-w64-mingw32-ranlib x86_64_CC=x86_64-w64-mingw32-gcc
|
||||
x86_64_CXX=x86_64-w64-mingw32-g++ x86_64_LD=x86_64-w64-mingw32-ld
|
||||
"x86_64_CFLAGS=$x86_64_flags" "x86_64_CPPFLAGS=$x86_64_flags" "x86_64_CXXFLAGS=-std=c++17 $x86_64_flags" "x86_64_LDFLAGS="
|
||||
"x86_64_PKG_CONFIG_LIBDIR=/usr/lib/x86_64-w64-mingw32/pkgconfig:/usr/share/pkgconfig")
|
||||
export PATH=/opt/llvm-mingw/bin:$PATH
|
||||
( cd "$s" && autoreconf -fi && rm -rf autom4te.cache ) > "$b/autoreconf.log" 2>&1
|
||||
rm -rf "$o" "$d"
|
||||
mkdir -p "$o" "$d"
|
||||
( cd "$o" && env "${env[@]}" "$conf" -C --prefix="$d" --libdir="$d/lib" --host=aarch64-linux-gnu "${env[@]}" \
|
||||
"${args[@]}" ) > "$b/configure.log" 2>&1
|
||||
( cd "$o" && env "${env[@]}" make -j"$jobs" __tooldeps__ ) > "$b/tools.log" 2>&1
|
||||
( cd "$o" && env "${env[@]}" make -j"$jobs" dlls/ntdll/ntdll.so server/wineserver ) > "$b/make.log" 2>&1
|
||||
mkdir -p "$out/files/lib/wine/aarch64-unix" "$out/files/bin-arm64"
|
||||
llvm-objcopy --strip-debug --set-section-flags .text=contents,alloc,load,readonly,code \
|
||||
"$o/dlls/ntdll/ntdll.so" "$out/files/lib/wine/aarch64-unix/ntdll.so"
|
||||
llvm-objcopy --strip-debug "$o/server/wineserver" "$out/files/bin-arm64/wineserver"
|
||||
chmod 0755 "$out/files/lib/wine/aarch64-unix/ntdll.so" "$out/files/bin-arm64/wineserver"
|
||||
cp "$s/include/wine/server_protocol.h" "$s/server/request_handlers.h" "$s/server/request_trace.h" "$out/"
|
||||
sed -n 's/^#define SERVER_PROTOCOL_VERSION \([0-9]*\)$/\1/p' "$out/server_protocol.h" > "$out/protocol"
|
||||
}
|
||||
|
||||
[ $# -ge 1 ] || usage
|
||||
case $1 in
|
||||
prepare)
|
||||
[ $# -ge 3 ] || usage
|
||||
prepare "$(realpath "$2")" "$(realpath -m "$3")" "${4:+$(realpath "$4")}"
|
||||
;;
|
||||
build)
|
||||
[ $# -eq 3 ] || usage
|
||||
build "$(realpath "$2")" "$(realpath -m "$3")"
|
||||
;;
|
||||
all)
|
||||
[ $# -ge 3 ] || usage
|
||||
b=${BUILD_DIR:-/builds/proton/proton/build-dir}
|
||||
prepare "$(realpath "$2")" "$b" "${4:+$(realpath "$4")}"
|
||||
build "$b" "$(realpath -m "$3")"
|
||||
;;
|
||||
*)
|
||||
usage
|
||||
;;
|
||||
esac
|
||||
@@ -1,654 +0,0 @@
|
||||
#!/usr/bin/env python3
|
||||
from __future__ import annotations
|
||||
|
||||
import argparse
|
||||
import hashlib
|
||||
import json
|
||||
import os
|
||||
import re
|
||||
import subprocess
|
||||
import sys
|
||||
import urllib.parse
|
||||
from datetime import datetime, timedelta, timezone
|
||||
from pathlib import Path
|
||||
|
||||
from make_index import check_entry
|
||||
from make_pack import FLAVORS, HERE, PATCHES, REVOKED, SERIES, PackError, patch_digest, read_revoked, sha256_file, slug
|
||||
|
||||
FLAVORS_FILE = HERE / "flavors.json"
|
||||
ARCHIVE = re.compile(r"\.tar\.(gz|xz)$")
|
||||
ASSIGNMENT = re.compile(r"(?:export\s+|override\s+)?([A-Za-z_][A-Za-z0-9_]*)\s*(?:\?|\+|!|:{1,3})?=\s*(.*)")
|
||||
REFERENCE = re.compile(r"\$[({]([A-Za-z_][A-Za-z0-9_]*)[)}]")
|
||||
IMAGE = re.compile(r"[A-Za-z0-9][A-Za-z0-9.-]*(?::[0-9]+)?(?:/[A-Za-z0-9._-]+)+(?::[A-Za-z0-9._-]+)?(?:@sha256:[0-9a-f]{64})?")
|
||||
REPO = re.compile(r"[A-Za-z0-9_.-]+/[A-Za-z0-9_.-]+")
|
||||
CLONES = ("shallow", "treeless")
|
||||
PACK_REV = re.compile(r"-r([0-9]+)$")
|
||||
ARTIFACT_PREFIX = "droiddeck-esync-pack-"
|
||||
FAILED = ".failed"
|
||||
RETRY_AFTER = timedelta(days=1)
|
||||
VDF_TOKEN = re.compile(r'"((?:[^"\\]|\\.)*)"|([{}])')
|
||||
APP_HEADER = re.compile(r"^AppID : ([0-9]+),", re.M)
|
||||
ANSI = re.compile(r"\x1b\[[0-9;]*[A-Za-z]")
|
||||
|
||||
|
||||
def gh(*args: str) -> subprocess.CompletedProcess:
|
||||
try:
|
||||
return subprocess.run(["gh", *args], capture_output=True, text=True, check=False)
|
||||
except FileNotFoundError as e:
|
||||
raise PackError("the GitHub CLI (gh) is not installed") from e
|
||||
|
||||
|
||||
def json_values(text: str) -> list:
|
||||
decoder = json.JSONDecoder()
|
||||
values = []
|
||||
position = 0
|
||||
while True:
|
||||
while position < len(text) and text[position].isspace():
|
||||
position += 1
|
||||
if position == len(text):
|
||||
return values
|
||||
value, position = decoder.raw_decode(text, position)
|
||||
values.append(value)
|
||||
|
||||
|
||||
def gh_api(path: str, paginate: bool = False, missing_ok: bool = False):
|
||||
result = gh("api", *(["--paginate"] if paginate else []), path)
|
||||
if result.returncode != 0:
|
||||
if missing_ok and "HTTP 404" in result.stderr:
|
||||
return None
|
||||
raise PackError(f"gh api {path}: {result.stderr.strip() or f'exit {result.returncode}'}")
|
||||
try:
|
||||
values = json_values(result.stdout)
|
||||
except ValueError as e:
|
||||
raise PackError(f"gh api {path}: {e}") from e
|
||||
if len(values) == 1:
|
||||
return values[0]
|
||||
if values and all(isinstance(value, list) for value in values):
|
||||
return [item for value in values for item in value]
|
||||
raise PackError(f"gh api {path}: unexpected output")
|
||||
|
||||
|
||||
def quote(value: str) -> str:
|
||||
return urllib.parse.quote(value, safe="")
|
||||
|
||||
|
||||
def load_flavors(path: Path) -> dict:
|
||||
try:
|
||||
data = json.loads(path.read_text())
|
||||
except (OSError, ValueError) as e:
|
||||
raise PackError(f"cannot read {path}: {e}") from e
|
||||
|
||||
def fail(why: str):
|
||||
raise PackError(f"{path}: {why}")
|
||||
|
||||
def compiles(pattern: str, where: str):
|
||||
try:
|
||||
re.compile(pattern)
|
||||
except re.error as e:
|
||||
fail(f"{where}: {pattern!r} is not a regular expression: {e}")
|
||||
|
||||
if not isinstance(data, dict) or data.get("format") != 1 or not isinstance(data.get("flavors"), dict):
|
||||
fail("is not a format 1 flavor list")
|
||||
image = data.get("sdk_image")
|
||||
if not isinstance(image, dict) or not all(isinstance(image.get(key), str) and image[key] for key in ("file", "variable", "match")):
|
||||
fail("sdk_image needs file, variable and match")
|
||||
for name, cfg in data["flavors"].items():
|
||||
if name not in FLAVORS:
|
||||
fail(f"unknown flavor {name!r}")
|
||||
if not isinstance(cfg, dict) or not isinstance(cfg.get("repo"), str) or not REPO.fullmatch(cfg["repo"]):
|
||||
fail(f"{name}: repo must be owner/name")
|
||||
for key in ("keep", "rev"):
|
||||
if type(cfg.get(key)) is not int or cfg[key] < 1:
|
||||
fail(f"{name}: {key} must be a positive number")
|
||||
if not isinstance(cfg.get("series"), str) or not SERIES.fullmatch(cfg["series"]):
|
||||
fail(f"{name}: series is not a patch series name")
|
||||
if cfg.get("profile") not in ("valve", "cachyos"):
|
||||
fail(f"{name}: profile must be valve or cachyos")
|
||||
if type(cfg.get("source_match")) is not bool:
|
||||
fail(f"{name}: source_match must be a boolean")
|
||||
build_dir = cfg.get("build_dir")
|
||||
if not isinstance(build_dir, str) or not re.fullmatch(r"(?:/[A-Za-z0-9._-]+)+", build_dir) or ".." in build_dir.split("/"):
|
||||
fail(f"{name}: build_dir must be the absolute path the release was built at")
|
||||
wine = cfg.get("wine")
|
||||
submodules = wine.get("submodules") if isinstance(wine, dict) else None
|
||||
if not isinstance(submodules, list) or "wine" not in submodules \
|
||||
or not all(isinstance(item, str) and re.fullmatch(r"[A-Za-z0-9._-]+(?:/[A-Za-z0-9._-]+)*", item) for item in submodules):
|
||||
fail(f"{name}: wine.submodules must list the submodules to check out, wine among them")
|
||||
if wine.get("clone") not in CLONES:
|
||||
fail(f"{name}: wine.clone must be one of {', '.join(CLONES)}")
|
||||
prep = wine.get("prep")
|
||||
if not isinstance(prep, str) or (prep and not re.fullmatch(r"[A-Za-z0-9._-]+(?:/[A-Za-z0-9._-]+)*", prep)) or ".." in prep.split("/"):
|
||||
fail(f"{name}: wine.prep must be a path inside the checkout or empty")
|
||||
if cfg.get("list") == "tags":
|
||||
families = cfg.get("families")
|
||||
if not isinstance(families, dict) or not families:
|
||||
fail(f"{name}: families must name at least one tag family")
|
||||
for family, settings in families.items():
|
||||
if not isinstance(settings, dict) or not isinstance(settings.get("tag"), str) \
|
||||
or not isinstance(settings.get("prefix"), str) or not re.fullmatch(r"[A-Za-z0-9._-]+", settings["prefix"]) \
|
||||
or not isinstance(settings.get("depot_app", ""), str):
|
||||
fail(f"{name}: family {family} needs a tag prefix and a tag pattern")
|
||||
compiles(settings["tag"], f"{name}: family {family}")
|
||||
if not isinstance(cfg.get("version_token"), str) or "{tag}" not in cfg["version_token"]:
|
||||
fail(f"{name}: version_token must contain {{tag}}")
|
||||
elif cfg.get("list") == "releases":
|
||||
if not isinstance(cfg.get("tag"), str) or not isinstance(cfg.get("assets"), list) or not cfg["assets"] \
|
||||
or not all(isinstance(pattern, str) for pattern in cfg["assets"]):
|
||||
fail(f"{name}: releases need a tag pattern and asset patterns")
|
||||
for pattern in (cfg["tag"], *cfg["assets"]):
|
||||
compiles(pattern, name)
|
||||
else:
|
||||
fail(f"{name}: list must be tags or releases")
|
||||
return data
|
||||
|
||||
|
||||
def natural_key(text: str) -> list[tuple]:
|
||||
return [(0, int(part), "") if part[0] in "0123456789" else (1, 0, part) for part in re.findall(r"[0-9]+|[^0-9]+", text)]
|
||||
|
||||
|
||||
def candidate(flavor: str, cfg: dict, tag: str, asset: str = "", token: str = "", depot_app: str = "") -> dict:
|
||||
return {
|
||||
"key": slug(f"{flavor}-{ARCHIVE.sub('', asset) if asset else tag}"),
|
||||
"flavor": flavor,
|
||||
"repo": cfg["repo"],
|
||||
"tag": tag,
|
||||
"asset": asset,
|
||||
"token": token,
|
||||
"depot_app": depot_app,
|
||||
"rev": cfg["rev"],
|
||||
"series": cfg["series"],
|
||||
"profile": cfg["profile"],
|
||||
"source_match": cfg["source_match"],
|
||||
"submodules": " ".join(cfg["wine"]["submodules"]),
|
||||
"clone": cfg["wine"]["clone"],
|
||||
"prep": cfg["wine"]["prep"],
|
||||
"build_dir": cfg["build_dir"],
|
||||
}
|
||||
|
||||
|
||||
def tag_candidates(flavor: str, cfg: dict, ref: str) -> list[dict]:
|
||||
found = []
|
||||
for family, settings in sorted(cfg["families"].items()):
|
||||
if ref and not ref.startswith(settings["prefix"]):
|
||||
continue
|
||||
refs = gh_api(f"repos/{cfg['repo']}/git/matching-refs/tags/{quote(settings['prefix'])}", paginate=True)
|
||||
if not isinstance(refs, list):
|
||||
raise PackError(f"{cfg['repo']}: the tag list is not a list")
|
||||
pattern = re.compile(settings["tag"])
|
||||
names = set()
|
||||
for item in refs:
|
||||
name = item.get("ref", "") if isinstance(item, dict) else ""
|
||||
if isinstance(name, str) and name.startswith("refs/tags/") and pattern.search(name[len("refs/tags/"):]):
|
||||
names.add(name[len("refs/tags/"):])
|
||||
ordered = sorted(names, key=natural_key, reverse=True)
|
||||
chosen = [name for name in ordered if name == ref] if ref else ordered[:cfg["keep"]]
|
||||
for name in chosen:
|
||||
found.append(candidate(flavor, cfg, name, token=cfg["version_token"].format(tag=name), depot_app=settings.get("depot_app", "")))
|
||||
return found
|
||||
|
||||
|
||||
def pick_assets(assets: list, patterns: list[re.Pattern]) -> list[str]:
|
||||
chosen = {}
|
||||
for asset in assets:
|
||||
name = asset.get("name") if isinstance(asset, dict) else None
|
||||
if not isinstance(name, str) or not any(pattern.search(name) for pattern in patterns):
|
||||
continue
|
||||
stem = ARCHIVE.sub("", name)
|
||||
if stem not in chosen or name.endswith(".tar.xz"):
|
||||
chosen[stem] = name
|
||||
return sorted(chosen.values())
|
||||
|
||||
|
||||
def release_candidates(flavor: str, cfg: dict, ref: str) -> list[dict]:
|
||||
repo = cfg["repo"]
|
||||
if ref:
|
||||
release = gh_api(f"repos/{repo}/releases/tags/{quote(ref)}", missing_ok=True)
|
||||
releases = [release] if release else []
|
||||
else:
|
||||
releases = gh_api(f"repos/{repo}/releases?per_page=100")
|
||||
if not isinstance(releases, list):
|
||||
raise PackError(f"{repo}: the release list is not a list")
|
||||
pattern = re.compile(cfg["tag"])
|
||||
patterns = [re.compile(item) for item in cfg["assets"]]
|
||||
usable = []
|
||||
for release in releases:
|
||||
tag = release.get("tag_name") if isinstance(release, dict) else None
|
||||
if not isinstance(tag, str) or release.get("draft") or not pattern.search(tag):
|
||||
continue
|
||||
assets = pick_assets(release.get("assets") or [], patterns)
|
||||
if assets:
|
||||
usable.append((release.get("published_at") or release.get("created_at") or "", natural_key(tag), tag, assets))
|
||||
usable.sort(reverse=True)
|
||||
if not ref:
|
||||
usable = usable[:cfg["keep"]]
|
||||
return [candidate(flavor, cfg, tag, asset=asset) for _, _, tag, assets in usable for asset in assets]
|
||||
|
||||
|
||||
def built(index: dict) -> dict[tuple[str, str, str], int]:
|
||||
revs = {}
|
||||
packs = index.get("packs") if isinstance(index, dict) else None
|
||||
for pack in packs if isinstance(packs, list) else []:
|
||||
if not isinstance(pack, dict) or not isinstance(pack.get("source"), dict):
|
||||
continue
|
||||
rev = pack.get("rev") if type(pack.get("rev")) is int else 0
|
||||
key = (pack.get("flavor"), pack["source"].get("ref"), pack["source"].get("asset", ""))
|
||||
revs[key] = max(revs.get(key, 0), rev)
|
||||
return revs
|
||||
|
||||
|
||||
def revoked_build(entry: dict, revoked: set[str]) -> bool:
|
||||
prefixes = {f"{entry['flavor']}-{slug(name)}-" for name in (entry["token"], entry["tag"]) if name}
|
||||
suffix = f"-r{entry['rev']}"
|
||||
return any(ident.endswith(suffix) and ident.startswith(prefix) for ident in revoked for prefix in prefixes)
|
||||
|
||||
|
||||
def chosen_flavors(flavors: dict, selected: str) -> list[str]:
|
||||
return sorted(flavors["flavors"]) if selected == "all" else [selected]
|
||||
|
||||
|
||||
def failure_marker(entry: dict, digests: dict[str, str] | None = None) -> str:
|
||||
series = entry["series"]
|
||||
if not SERIES.fullmatch(series):
|
||||
raise PackError(f"{series!r} is not a patch series name")
|
||||
digest = digests.get(series) if digests is not None else None
|
||||
if digest is None:
|
||||
digest = patch_digest(PATCHES / series)
|
||||
if digests is not None:
|
||||
digests[series] = digest
|
||||
return f"{entry['key']}-r{entry['rev']}-{digest[:12]}{FAILED}"
|
||||
|
||||
|
||||
def discover(flavors: dict, selected: str, ref: str, index: dict, revoked: set[str],
|
||||
failed: frozenset[str] = frozenset()) -> list[dict]:
|
||||
names = chosen_flavors(flavors, selected)
|
||||
done = built(index)
|
||||
digests = {}
|
||||
entries = []
|
||||
seen = set()
|
||||
matched = False
|
||||
for flavor in names:
|
||||
cfg = flavors["flavors"].get(flavor)
|
||||
if cfg is None:
|
||||
raise PackError(f"flavors.json has no {flavor}")
|
||||
found = tag_candidates(flavor, cfg, ref) if cfg["list"] == "tags" else release_candidates(flavor, cfg, ref)
|
||||
matched = matched or bool(found)
|
||||
for entry in found:
|
||||
if entry["key"] in seen:
|
||||
continue
|
||||
seen.add(entry["key"])
|
||||
label = f"{flavor} {entry['tag']}{' ' + entry['asset'] if entry['asset'] else ''}"
|
||||
if revoked_build(entry, revoked):
|
||||
print(f"discover: {label}: revoked at rev {entry['rev']}", file=sys.stderr)
|
||||
elif done.get((flavor, entry["tag"], entry["asset"]), 0) >= entry["rev"]:
|
||||
print(f"discover: {label}: in the index at rev {entry['rev']}", file=sys.stderr)
|
||||
elif not ref and failure_marker(entry, digests) in failed:
|
||||
print(f"discover: {label}: failed at rev {entry['rev']} with this patch series in the last "
|
||||
f"{RETRY_AFTER.days} days; skipped (bump rev, change the series or build the tag by name)", file=sys.stderr)
|
||||
else:
|
||||
print(f"discover: {label}: to build", file=sys.stderr)
|
||||
entries.append(entry)
|
||||
if ref and not matched:
|
||||
raise PackError(f"no {'' if selected == 'all' else selected + ' '}build is tagged {ref}")
|
||||
return entries
|
||||
|
||||
|
||||
def vdf(text: str) -> dict:
|
||||
stack = [{}]
|
||||
key = None
|
||||
for match in VDF_TOKEN.finditer(text):
|
||||
word, brace = match.group(1), match.group(2)
|
||||
if brace == "{":
|
||||
if key is None:
|
||||
raise PackError("app info: a block has no name")
|
||||
child = {}
|
||||
stack[-1][key] = child
|
||||
stack.append(child)
|
||||
key = None
|
||||
elif brace == "}":
|
||||
if len(stack) == 1:
|
||||
raise PackError("app info: unbalanced braces")
|
||||
stack.pop()
|
||||
key = None
|
||||
elif key is None:
|
||||
key = word
|
||||
else:
|
||||
stack[-1][key] = word
|
||||
key = None
|
||||
if len(stack) != 1:
|
||||
raise PackError("app info: unbalanced braces")
|
||||
return stack[0]
|
||||
|
||||
|
||||
def steam_builds(text: str, apps: list[str]) -> dict[str, dict]:
|
||||
found = {}
|
||||
text = ANSI.sub("", text)
|
||||
starts = [(m.start(), m.group(1)) for m in APP_HEADER.finditer(text)]
|
||||
for number, (start, app) in enumerate(starts):
|
||||
end = starts[number + 1][0] if number + 1 < len(starts) else len(text)
|
||||
if app not in apps:
|
||||
continue
|
||||
body = text[text.find("\n", start) + 1:end]
|
||||
info = vdf(body).get(app)
|
||||
depots = info.get("depots") if isinstance(info, dict) else None
|
||||
public = depots.get("branches", {}).get("public") if isinstance(depots, dict) else None
|
||||
if not isinstance(public, dict) or not str(public.get("buildid", "")).isdigit():
|
||||
continue
|
||||
manifests = sorted(depot["manifests"]["public"]["gid"] for name, depot in depots.items()
|
||||
if name.isdigit() and isinstance(depot, dict) and isinstance(depot.get("manifests"), dict)
|
||||
and isinstance(depot["manifests"].get("public"), dict) and depot["manifests"]["public"].get("gid"))
|
||||
found[app] = {"buildid": public["buildid"], "built": public.get("timebuildupdated", ""), "manifests": manifests}
|
||||
return found
|
||||
|
||||
|
||||
def steam_apps(flavors: dict) -> list[str]:
|
||||
return sorted({family["depot_app"] for cfg in flavors["flavors"].values() if cfg["list"] == "tags"
|
||||
for family in cfg["families"].values() if family.get("depot_app")})
|
||||
|
||||
|
||||
def watch(flavors: dict, previous: dict, steam: dict[str, dict] | None) -> tuple[dict, list[str], list[str]]:
|
||||
state = {}
|
||||
changed = []
|
||||
notes = []
|
||||
for flavor in sorted(flavors["flavors"]):
|
||||
cfg = flavors["flavors"][flavor]
|
||||
found = tag_candidates(flavor, cfg, "") if cfg["list"] == "tags" else release_candidates(flavor, cfg, "")
|
||||
builds = sorted(f"{entry['tag']} {entry['asset']}".strip() for entry in found)
|
||||
ships = {}
|
||||
if cfg["list"] == "tags" and steam is not None:
|
||||
for family in cfg["families"].values():
|
||||
app = family.get("depot_app")
|
||||
if app and app in steam:
|
||||
ships[app] = steam[app]
|
||||
old = previous.get(flavor) if isinstance(previous.get(flavor), dict) else {}
|
||||
if steam is None and isinstance(old.get("steam"), dict):
|
||||
ships = old["steam"]
|
||||
mark = {"builds": builds, "rev": cfg["rev"], "series": cfg["series"], "patch": patch_digest(PATCHES / cfg["series"])}
|
||||
fingerprint = hashlib.sha256(json.dumps(mark, sort_keys=True).encode()).hexdigest()
|
||||
state[flavor] = {**mark, "fingerprint": fingerprint, "steam": ships}
|
||||
if old.get("fingerprint") != fingerprint:
|
||||
changed.append(flavor)
|
||||
fresh = sorted(set(builds) - set(old.get("builds") or []))
|
||||
notes.append(f"{flavor}: {', '.join(fresh) if fresh else 'the patch series or rev changed'}")
|
||||
for app, ship in sorted(ships.items()):
|
||||
before = (old.get("steam") or {}).get(app) if isinstance(old.get("steam"), dict) else None
|
||||
if isinstance(before, dict) and before.get("buildid") != ship.get("buildid"):
|
||||
notes.append(f"{flavor}: Steam app {app} moved from build {before.get('buildid')} to {ship.get('buildid')}")
|
||||
if flavor not in changed:
|
||||
changed.append(flavor)
|
||||
return state, changed, notes
|
||||
|
||||
|
||||
def asset_text(repo: str, asset_id, what: str) -> str:
|
||||
result = gh("api", "-H", "Accept: application/octet-stream", f"repos/{repo}/releases/assets/{asset_id}")
|
||||
if result.returncode != 0:
|
||||
raise PackError(f"cannot download {what}: {result.stderr.strip()}")
|
||||
return result.stdout
|
||||
|
||||
|
||||
def release_index(repo: str, tag: str) -> dict:
|
||||
release = gh_api(f"repos/{repo}/releases/tags/{quote(tag)}", missing_ok=True)
|
||||
if release is None:
|
||||
return {}
|
||||
for asset in release.get("assets") or []:
|
||||
if isinstance(asset, dict) and asset.get("name") == "index.json":
|
||||
text = asset_text(repo, asset["id"], f"the index of {repo}")
|
||||
try:
|
||||
return json.loads(text)
|
||||
except ValueError as e:
|
||||
raise PackError(f"the index of {repo} is not JSON: {e}") from e
|
||||
return {}
|
||||
|
||||
|
||||
def published(repo: str, flavors: dict, selected: str, index: dict) -> list[dict]:
|
||||
packs = index.get("packs") if isinstance(index, dict) else None
|
||||
listed = {pack.get("id") for pack in packs if isinstance(pack, dict)} if isinstance(packs, list) else set()
|
||||
found = []
|
||||
for flavor in chosen_flavors(flavors, selected):
|
||||
cfg = flavors["flavors"].get(flavor)
|
||||
tag = f"droiddeck-esync-{flavor}"
|
||||
release = gh_api(f"repos/{repo}/releases/tags/{quote(tag)}", missing_ok=True) if cfg else None
|
||||
if not isinstance(release, dict) or type(release.get("id")) is not int:
|
||||
continue
|
||||
assets = gh_api(f"repos/{repo}/releases/{release['id']}/assets?per_page=100", paginate=True)
|
||||
if not isinstance(assets, list):
|
||||
raise PackError(f"{repo} {tag}: the asset list is not a list")
|
||||
for asset in assets:
|
||||
name = asset.get("name") if isinstance(asset, dict) else None
|
||||
if not isinstance(name, str) or not name.endswith(".json"):
|
||||
continue
|
||||
ident = name[:-len(".json")]
|
||||
rev = PACK_REV.search(ident)
|
||||
if ident in listed or not rev or int(rev.group(1)) < cfg["rev"]:
|
||||
continue
|
||||
try:
|
||||
entry = json.loads(asset_text(repo, asset.get("id"), f"{tag} {name}"))
|
||||
except ValueError:
|
||||
entry = None
|
||||
if not isinstance(entry, dict) or entry.get("id") != ident or entry.get("flavor") != flavor:
|
||||
print(f"discover: {tag} {name} is not a pack entry", file=sys.stderr)
|
||||
continue
|
||||
print(f"discover: {tag} {name}: published, not in the index yet", file=sys.stderr)
|
||||
found.append(entry)
|
||||
return found
|
||||
|
||||
|
||||
def parse_time(value) -> datetime | None:
|
||||
if not isinstance(value, str):
|
||||
return None
|
||||
try:
|
||||
moment = datetime.fromisoformat(value.replace("Z", "+00:00"))
|
||||
except ValueError:
|
||||
return None
|
||||
return moment if moment.tzinfo else moment.replace(tzinfo=timezone.utc)
|
||||
|
||||
|
||||
def recent_failures(repo: str, flavors: dict, selected: str, now: datetime) -> frozenset[str]:
|
||||
found = set()
|
||||
for flavor in chosen_flavors(flavors, selected):
|
||||
tag = f"droiddeck-esync-{flavor}"
|
||||
release = gh_api(f"repos/{repo}/releases/tags/{quote(tag)}", missing_ok=True) if flavor in flavors["flavors"] else None
|
||||
if not isinstance(release, dict) or type(release.get("id")) is not int:
|
||||
continue
|
||||
assets = gh_api(f"repos/{repo}/releases/{release['id']}/assets?per_page=100", paginate=True)
|
||||
if not isinstance(assets, list):
|
||||
raise PackError(f"{repo} {tag}: the asset list is not a list")
|
||||
for asset in assets:
|
||||
name = asset.get("name") if isinstance(asset, dict) else None
|
||||
if not isinstance(name, str) or not name.endswith(FAILED):
|
||||
continue
|
||||
moment = parse_time(asset.get("updated_at")) or parse_time(asset.get("created_at"))
|
||||
if moment is not None and now - moment < RETRY_AFTER:
|
||||
found.add(name)
|
||||
return frozenset(found)
|
||||
|
||||
|
||||
def failed_builds(matrix: dict, directory: Path) -> list[tuple[str, str]]:
|
||||
rows = matrix.get("include") if isinstance(matrix, dict) else None
|
||||
if not isinstance(rows, list) or not all(isinstance(row, dict) and isinstance(row.get("key"), str) for row in rows):
|
||||
raise PackError("the build matrix has no include list")
|
||||
made = {row["key"] for row in rows if (directory / f"{ARTIFACT_PREFIX}{row['key']}").is_dir()}
|
||||
digests = {}
|
||||
return [(row["flavor"], failure_marker(row, digests)) for row in rows if row["key"] not in made]
|
||||
|
||||
|
||||
def artifact_packs(matrix: dict, directory: Path) -> list[tuple[str, Path, str]]:
|
||||
rows = matrix.get("include") if isinstance(matrix, dict) else None
|
||||
if not isinstance(rows, list) or not all(isinstance(row, dict) and isinstance(row.get("key"), str) for row in rows):
|
||||
raise PackError("the build matrix has no include list")
|
||||
builds = {row["key"]: row for row in rows}
|
||||
found = []
|
||||
for folder in sorted(directory.iterdir()) if directory.is_dir() else []:
|
||||
row = builds.get(folder.name[len(ARTIFACT_PREFIX):]) if folder.name.startswith(ARTIFACT_PREFIX) else None
|
||||
if row is None or folder.is_symlink() or not folder.is_dir():
|
||||
raise PackError(f"{folder.name} is not the artifact of a build in this run")
|
||||
names = sorted(path.name for path in folder.iterdir())
|
||||
entries = [name for name in names if name.endswith(".json")]
|
||||
if len(entries) != 1 or names != sorted([entries[0], entries[0][:-len(".json")] + ".tzst"]):
|
||||
raise PackError(f"{folder.name} must hold exactly <id>.json and <id>.tzst")
|
||||
ident = entries[0][:-len(".json")]
|
||||
entry_path, archive = folder / entries[0], folder / f"{ident}.tzst"
|
||||
if entry_path.is_symlink() or archive.is_symlink() or not entry_path.is_file() or not archive.is_file():
|
||||
raise PackError(f"{folder.name} holds links or special files")
|
||||
try:
|
||||
data = json.loads(entry_path.read_text())
|
||||
except ValueError as e:
|
||||
raise PackError(f"{entry_path}: {e}") from e
|
||||
entry = check_entry(data, str(entry_path))
|
||||
source = data.get("source") if isinstance(data.get("source"), dict) else {}
|
||||
if entry["id"] != ident or entry["flavor"] != row["flavor"] or entry["rev"] != row["rev"] \
|
||||
or source.get("ref") != row["tag"] or source.get("asset", "") != row["asset"]:
|
||||
raise PackError(f"{entry_path} is not the pack of {row['flavor']} {row['tag']} at rev {row['rev']}")
|
||||
if archive.stat().st_size != entry["asset"]["size"] or sha256_file(archive) != entry["asset"]["sha256"]:
|
||||
raise PackError(f"{archive} is not the asset its entry describes")
|
||||
found.append((row["flavor"], folder, ident))
|
||||
return found
|
||||
|
||||
|
||||
def emit(entries: list[dict], unindexed: int = 0) -> None:
|
||||
matrix = json.dumps({"include": entries}, sort_keys=True, separators=(",", ":"))
|
||||
path = os.environ.get("GITHUB_OUTPUT")
|
||||
if path:
|
||||
with open(path, "a") as stream:
|
||||
stream.write(f"matrix={matrix}\ncount={len(entries)}\nunindexed={unindexed}\n")
|
||||
print(matrix)
|
||||
|
||||
|
||||
def make_variables(text: str) -> tuple[dict[str, str], list[tuple[str, str]]]:
|
||||
variables = {}
|
||||
assignments = []
|
||||
for raw in text.splitlines():
|
||||
match = ASSIGNMENT.fullmatch(raw.split("#", 1)[0].strip())
|
||||
if match:
|
||||
name, value = match.group(1), match.group(2).strip()
|
||||
variables.setdefault(name, value)
|
||||
assignments.append((name, value))
|
||||
return variables, assignments
|
||||
|
||||
|
||||
def expand(value: str, variables: dict[str, str], depth: int = 0) -> str:
|
||||
if depth > 16:
|
||||
raise PackError("Makefile variables nest too deeply")
|
||||
|
||||
def lookup(match: re.Match) -> str:
|
||||
if match.group(1) not in variables:
|
||||
raise PackError(f"$({match.group(1)}) is not set in the Makefile")
|
||||
return expand(variables[match.group(1)], variables, depth + 1)
|
||||
|
||||
return REFERENCE.sub(lookup, value)
|
||||
|
||||
|
||||
def sdk_image(text: str, variable: str = "STEAMRT_IMAGE", match: str = "arm64-llvm") -> str:
|
||||
variables, assignments = make_variables(text)
|
||||
problem = None
|
||||
for name, value in assignments:
|
||||
if not name.startswith(variable):
|
||||
continue
|
||||
try:
|
||||
image = expand(value, variables)
|
||||
except PackError as e:
|
||||
problem = problem or e
|
||||
continue
|
||||
if match not in image:
|
||||
continue
|
||||
if not IMAGE.fullmatch(image):
|
||||
raise PackError(f"{name} = {image!r} is not an image reference")
|
||||
return image
|
||||
raise problem or PackError(f"no {variable} assignment names an {match} image")
|
||||
|
||||
|
||||
def main(argv: list[str] | None = None) -> int:
|
||||
parser = argparse.ArgumentParser(description="Find the Proton builds that have no droiddeck-esync pack yet, as a GitHub Actions matrix.")
|
||||
parser.add_argument("--flavors", default=str(FLAVORS_FILE))
|
||||
commands = parser.add_subparsers(dest="command", required=True)
|
||||
matrix = commands.add_parser("matrix")
|
||||
matrix.add_argument("--flavor", default="all", choices=("all", *FLAVORS))
|
||||
matrix.add_argument("--ref", default="")
|
||||
matrix.add_argument("--index", default="")
|
||||
matrix.add_argument("--index-release", default="")
|
||||
matrix.add_argument("--repo", default=os.environ.get("GITHUB_REPOSITORY", "Droid-Deck/DroidDeck"))
|
||||
matrix.add_argument("--revoked", default=str(REVOKED))
|
||||
image = commands.add_parser("sdk-image")
|
||||
image.add_argument("makefile")
|
||||
artifacts = commands.add_parser("packs")
|
||||
artifacts.add_argument("--matrix", required=True)
|
||||
artifacts.add_argument("directory")
|
||||
failures = commands.add_parser("failures")
|
||||
failures.add_argument("--matrix", required=True)
|
||||
failures.add_argument("directory")
|
||||
commands.add_parser("steam-apps")
|
||||
watching = commands.add_parser("watch")
|
||||
watching.add_argument("--state", default="")
|
||||
watching.add_argument("--steam-info", default="")
|
||||
watching.add_argument("--out", required=True)
|
||||
args = parser.parse_args(argv)
|
||||
try:
|
||||
flavors = load_flavors(Path(args.flavors))
|
||||
if args.command == "sdk-image":
|
||||
settings = flavors["sdk_image"]
|
||||
print(sdk_image(Path(args.makefile).read_text(), settings["variable"], settings["match"]))
|
||||
return 0
|
||||
if args.command == "packs":
|
||||
for flavor, folder, ident in artifact_packs(json.loads(args.matrix), Path(args.directory)):
|
||||
print(f"{flavor}\t{folder}\t{ident}")
|
||||
return 0
|
||||
if args.command == "failures":
|
||||
for flavor, marker in failed_builds(json.loads(args.matrix), Path(args.directory)):
|
||||
print(f"{flavor}\t{marker}")
|
||||
return 0
|
||||
if args.command == "steam-apps":
|
||||
print(" ".join(steam_apps(flavors)))
|
||||
return 0
|
||||
if args.command == "watch":
|
||||
previous = {}
|
||||
if args.state and Path(args.state).is_file():
|
||||
try:
|
||||
previous = json.loads(Path(args.state).read_text())
|
||||
except ValueError:
|
||||
print("discover: the previous watch state is not JSON; every flavor counts as changed", file=sys.stderr)
|
||||
previous = previous.get("flavors", {}) if isinstance(previous, dict) and previous.get("format") == 1 else {}
|
||||
steam = None
|
||||
if args.steam_info:
|
||||
try:
|
||||
steam = steam_builds(Path(args.steam_info).read_text(errors="replace"), steam_apps(flavors))
|
||||
except (OSError, PackError) as e:
|
||||
print(f"discover: Steam app info unusable ({e}); watching the source tags only", file=sys.stderr)
|
||||
if steam is not None and len(steam) != len(steam_apps(flavors)):
|
||||
print(f"discover: Steam app info covers {sorted(steam)} of {steam_apps(flavors)}", file=sys.stderr)
|
||||
state, changed, notes = watch(flavors, previous, steam)
|
||||
Path(args.out).write_text(json.dumps({"format": 1, "flavors": state}, indent=1, sort_keys=True) + "\n")
|
||||
for note in notes:
|
||||
print(f"discover: {note}", file=sys.stderr)
|
||||
path = os.environ.get("GITHUB_OUTPUT")
|
||||
if path:
|
||||
with open(path, "a") as stream:
|
||||
stream.write(f"changed={' '.join(changed)}\n")
|
||||
print(" ".join(changed))
|
||||
return 0
|
||||
if args.index and args.index_release:
|
||||
raise PackError("pass --index or --index-release, not both")
|
||||
failed = frozenset()
|
||||
unindexed = 0
|
||||
if args.index:
|
||||
path = Path(args.index)
|
||||
index = json.loads(path.read_text()) if path.exists() else {}
|
||||
elif args.index_release:
|
||||
if not REPO.fullmatch(args.repo):
|
||||
raise PackError(f"{args.repo!r} is not owner/name")
|
||||
index = release_index(args.repo, args.index_release)
|
||||
listed = index.get("packs") if isinstance(index, dict) and isinstance(index.get("packs"), list) else []
|
||||
waiting = published(args.repo, flavors, args.flavor, index)
|
||||
unindexed = len(waiting)
|
||||
index = {"packs": [*listed, *waiting]}
|
||||
failed = recent_failures(args.repo, flavors, args.flavor, datetime.now(timezone.utc))
|
||||
else:
|
||||
index = {}
|
||||
revoked = read_revoked(Path(args.revoked)) if args.revoked else set()
|
||||
emit(discover(flavors, args.flavor, args.ref.strip(), index, revoked, failed), unindexed)
|
||||
except (PackError, OSError, ValueError) as e:
|
||||
print(f"discover: {e}", file=sys.stderr)
|
||||
return 1
|
||||
return 0
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
raise SystemExit(main())
|
||||
@@ -1,84 +0,0 @@
|
||||
{
|
||||
"format": 1,
|
||||
"sdk_image": {
|
||||
"file": "Makefile.in",
|
||||
"variable": "STEAMRT_IMAGE",
|
||||
"match": "arm64-llvm"
|
||||
},
|
||||
"flavors": {
|
||||
"valve": {
|
||||
"repo": "ValveSoftware/Proton",
|
||||
"list": "tags",
|
||||
"families": {
|
||||
"experimental": {
|
||||
"prefix": "experimental-11.0-",
|
||||
"tag": "^experimental-11\\.0-\\d{8}[a-z]?$",
|
||||
"depot_app": "4427310"
|
||||
},
|
||||
"proton": {
|
||||
"prefix": "proton-11.0-",
|
||||
"tag": "^proton-11\\.0-\\d+[a-z]?$",
|
||||
"depot_app": "4628740"
|
||||
}
|
||||
},
|
||||
"version_token": "{tag}-arm64",
|
||||
"keep": 2,
|
||||
"rev": 1,
|
||||
"series": "valve-11",
|
||||
"profile": "valve",
|
||||
"source_match": true,
|
||||
"build_dir": "/builds/proton/proton/build-dir",
|
||||
"wine": {
|
||||
"submodules": [
|
||||
"wine"
|
||||
],
|
||||
"clone": "shallow",
|
||||
"prep": ""
|
||||
}
|
||||
},
|
||||
"ge": {
|
||||
"repo": "GloriousEggroll/proton-ge-custom",
|
||||
"list": "releases",
|
||||
"tag": "^GE-Proton11-\\d+$",
|
||||
"assets": [
|
||||
"aarch64\\.tar\\.(gz|xz)$",
|
||||
"arm64\\.tar\\.(gz|xz)$"
|
||||
],
|
||||
"keep": 3,
|
||||
"rev": 1,
|
||||
"series": "valve-11",
|
||||
"profile": "valve",
|
||||
"source_match": false,
|
||||
"build_dir": "/home/tcrider/build",
|
||||
"wine": {
|
||||
"submodules": [
|
||||
"wine",
|
||||
"wine-staging"
|
||||
],
|
||||
"clone": "treeless",
|
||||
"prep": "patches/protonprep-valve-staging.sh"
|
||||
}
|
||||
},
|
||||
"cachyos": {
|
||||
"repo": "CachyOS/proton-cachyos",
|
||||
"list": "releases",
|
||||
"tag": "^cachyos-11\\.0-",
|
||||
"assets": [
|
||||
"arm64\\.tar\\.(gz|xz)$"
|
||||
],
|
||||
"keep": 3,
|
||||
"rev": 1,
|
||||
"series": "cachyos-11",
|
||||
"profile": "cachyos",
|
||||
"source_match": false,
|
||||
"build_dir": "/home/runner/work/proton-cachyos/proton-cachyos/build",
|
||||
"wine": {
|
||||
"submodules": [
|
||||
"wine"
|
||||
],
|
||||
"clone": "shallow",
|
||||
"prep": ""
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,4 +0,0 @@
|
||||
-----BEGIN PUBLIC KEY-----
|
||||
MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEFyqZQAMh3g3nsEGLU+kBGVPBEkXr
|
||||
Dv5F3kPtuQ+FV1DkTCGmYUQ1LS9wJtHGt0Ht4wToHGGEp9yzDibYZ4/zhg==
|
||||
-----END PUBLIC KEY-----
|
||||
@@ -1,285 +0,0 @@
|
||||
#!/usr/bin/env python3
|
||||
from __future__ import annotations
|
||||
|
||||
import argparse
|
||||
import datetime as dt
|
||||
import json
|
||||
import os
|
||||
import re
|
||||
import subprocess
|
||||
import sys
|
||||
import tempfile
|
||||
import time
|
||||
from pathlib import Path
|
||||
|
||||
from make_pack import (
|
||||
BINARIES,
|
||||
EPOCH,
|
||||
FLAVORS,
|
||||
HERE,
|
||||
NTDLL,
|
||||
PACK_ID,
|
||||
REVOKED,
|
||||
SHA256,
|
||||
WINESERVER,
|
||||
PackError,
|
||||
compress,
|
||||
dump_json,
|
||||
read_revoked,
|
||||
sha256_bytes,
|
||||
sha256_file,
|
||||
tar_bytes,
|
||||
write_atomic,
|
||||
)
|
||||
|
||||
PUBKEY = HERE / "index-key.pub"
|
||||
SCHEMA = 1
|
||||
INDEX_KEYS = ("id", "flavor", "rev", "version", "version_line", "stock", "exports", "source_match", "files", "protocol", "source", "patch")
|
||||
|
||||
|
||||
def check_entry(entry, origin: str) -> dict:
|
||||
def fail(why: str):
|
||||
raise PackError(f"{origin}: {why}")
|
||||
|
||||
if not isinstance(entry, dict):
|
||||
fail("is not an object")
|
||||
ident = entry.get("id")
|
||||
if not isinstance(ident, str) or not PACK_ID.fullmatch(ident):
|
||||
fail(f"{ident!r} is not a pack id")
|
||||
if entry.get("flavor") not in FLAVORS:
|
||||
fail(f"unknown flavor {entry.get('flavor')!r}")
|
||||
if type(entry.get("rev")) is not int or entry["rev"] < 1:
|
||||
fail("rev is not a positive number")
|
||||
version, line = entry.get("version"), entry.get("version_line")
|
||||
fields = line.split() if isinstance(line, str) else []
|
||||
if not isinstance(version, str) or len(fields) < 2 or fields[1] != version or not EPOCH.fullmatch(fields[0]):
|
||||
fail("version and version_line disagree")
|
||||
for field in ("stock", "files"):
|
||||
value = entry.get(field)
|
||||
if not isinstance(value, dict) or set(value) != set(BINARIES) or not all(isinstance(v, str) and SHA256.fullmatch(v) for v in value.values()):
|
||||
fail(f"{field} must give the sha256 of {' and '.join(BINARIES)}")
|
||||
if not isinstance(entry.get("exports"), str) or not SHA256.fullmatch(entry["exports"]):
|
||||
fail("exports is not a sha256")
|
||||
if type(entry.get("source_match")) is not bool:
|
||||
fail("source_match is not a boolean")
|
||||
asset = entry.get("asset")
|
||||
if not isinstance(asset, dict) or not isinstance(asset.get("sha256"), str) or not SHA256.fullmatch(asset["sha256"]) \
|
||||
or type(asset.get("size")) is not int or asset["size"] <= 0:
|
||||
fail("asset needs its sha256 and size")
|
||||
clean = {key: entry[key] for key in INDEX_KEYS if key in entry}
|
||||
clean["asset"] = {"sha256": asset["sha256"], "size": asset["size"]}
|
||||
return clean
|
||||
|
||||
|
||||
def load_entries(directory: Path) -> list[dict]:
|
||||
if not directory.is_dir():
|
||||
raise PackError(f"{directory} is not a directory")
|
||||
entries = []
|
||||
for path in sorted(directory.glob("*.json")):
|
||||
try:
|
||||
data = json.loads(path.read_text())
|
||||
except ValueError as e:
|
||||
raise PackError(f"{path}: {e}") from e
|
||||
entry = check_entry(data, str(path))
|
||||
if path.stem != entry["id"]:
|
||||
raise PackError(f"{path} holds the entry of {entry['id']}")
|
||||
entries.append(entry)
|
||||
return entries
|
||||
|
||||
|
||||
def load_previous(path: Path) -> tuple[int, list[dict], list]:
|
||||
try:
|
||||
data = json.loads(path.read_text())
|
||||
except (OSError, ValueError) as e:
|
||||
raise PackError(f"cannot read the previous index {path}: {e}") from e
|
||||
if not isinstance(data, dict) or data.get("schema") != SCHEMA or type(data.get("generated")) is not int \
|
||||
or not isinstance(data.get("packs"), list):
|
||||
raise PackError(f"{path} is not a schema {SCHEMA} index")
|
||||
packs = []
|
||||
for number, pack in enumerate(data["packs"]):
|
||||
entry = check_entry(pack, f"{path} pack {number}")
|
||||
entry["revoked"] = pack.get("revoked") is True
|
||||
packs.append(entry)
|
||||
return data["generated"], packs, data["packs"]
|
||||
|
||||
|
||||
def epoch(entry: dict) -> int:
|
||||
return int(entry["version_line"].split()[0])
|
||||
|
||||
|
||||
def rank(entry: dict) -> tuple:
|
||||
return entry["rev"], epoch(entry), entry["id"]
|
||||
|
||||
|
||||
def choose(entries: list[dict], previous: list[dict], revoked: set[str]) -> list[dict]:
|
||||
known = {entry["id"]: entry for entry in entries}
|
||||
for entry in previous:
|
||||
known.setdefault(entry["id"], entry)
|
||||
active = {}
|
||||
withdrawn = []
|
||||
for entry in known.values():
|
||||
if entry["id"] in revoked:
|
||||
withdrawn.append(dict(entry, revoked=True))
|
||||
continue
|
||||
key = (entry["stock"][NTDLL], entry["stock"][WINESERVER], entry["version"])
|
||||
if key not in active or rank(entry) > rank(active[key]):
|
||||
active[key] = dict(entry, revoked=False)
|
||||
return sorted([*active.values(), *withdrawn], key=lambda entry: entry["id"])
|
||||
|
||||
|
||||
def build_index(packs: list[dict], base_url: str, generated: int) -> dict:
|
||||
listed = []
|
||||
for pack in packs:
|
||||
entry = dict(pack)
|
||||
entry["asset"] = {
|
||||
"url": f"{base_url}/droiddeck-esync-{pack['flavor']}/{pack['id']}.tzst",
|
||||
"sha256": pack["asset"]["sha256"],
|
||||
"size": pack["asset"]["size"],
|
||||
}
|
||||
listed.append(entry)
|
||||
return {"schema": SCHEMA, "generated": generated, "packs": listed}
|
||||
|
||||
|
||||
def family(entry: dict) -> tuple[str, str, str]:
|
||||
token = entry["version"]
|
||||
major = re.search(r"[0-9]+", token)
|
||||
return entry["flavor"], re.match(r"[A-Za-z]*", token).group(0).lower(), major.group(0) if major else ""
|
||||
|
||||
|
||||
def bundle_choice(packs: list[dict], available: set[str] | None = None) -> list[dict]:
|
||||
newest = {}
|
||||
for pack in packs:
|
||||
if pack["revoked"] or (available is not None and pack["id"] not in available):
|
||||
continue
|
||||
key = family(pack)
|
||||
if key not in newest or (epoch(pack), pack["rev"], pack["id"]) > (epoch(newest[key]), newest[key]["rev"], newest[key]["id"]):
|
||||
newest[key] = pack
|
||||
return sorted(newest.values(), key=lambda pack: pack["id"])
|
||||
|
||||
|
||||
def openssl(*args: str) -> subprocess.CompletedProcess:
|
||||
try:
|
||||
return subprocess.run(["openssl", *args], capture_output=True, text=True, check=False)
|
||||
except FileNotFoundError as e:
|
||||
raise PackError("the openssl command is not installed") from e
|
||||
|
||||
|
||||
def verified(index: Path, signature: Path, pubkey: Path) -> bool:
|
||||
result = openssl("dgst", "-sha256", "-verify", str(pubkey), "-signature", str(signature), str(index))
|
||||
return result.returncode == 0 and "Verified OK" in result.stdout
|
||||
|
||||
|
||||
def trusted_previous(path: Path, signature: Path | None, pubkey: Path) -> tuple[int, list[dict], list | None]:
|
||||
if signature is not None and not (path.is_file() and signature.is_file() and verified(path, signature, pubkey)):
|
||||
print(f"make_index: the previous index {path} does not verify with {signature} and {pubkey}; it is ignored", file=sys.stderr)
|
||||
return 0, [], None
|
||||
return load_previous(path)
|
||||
|
||||
|
||||
def sign(index: Path, signature: Path, key: Path | None, pubkey: Path) -> None:
|
||||
with tempfile.TemporaryDirectory() as tmp:
|
||||
if key is None:
|
||||
pem = os.environ.get("SYNC_INDEX_KEY", "")
|
||||
if not pem.strip():
|
||||
raise PackError("no signing key: pass --key or set SYNC_INDEX_KEY")
|
||||
key = Path(tmp) / "key.pem"
|
||||
with os.fdopen(os.open(key, os.O_WRONLY | os.O_CREAT | os.O_EXCL, 0o600), "w") as stream:
|
||||
stream.write(pem if pem.endswith("\n") else pem + "\n")
|
||||
result = openssl("dgst", "-sha256", "-sign", str(key), "-out", str(signature), str(index))
|
||||
if result.returncode != 0:
|
||||
raise PackError(f"openssl could not sign the index: {result.stderr.strip()}")
|
||||
if not verified(index, signature, pubkey):
|
||||
raise PackError(f"the signature does not verify with {pubkey}: the signing key is not the one the app trusts")
|
||||
|
||||
|
||||
def bundle_name(generated: int) -> str:
|
||||
return f"bundle-{dt.datetime.fromtimestamp(generated, dt.timezone.utc):%Y%m%d-%H%M%S}.tzst"
|
||||
|
||||
|
||||
def bundle(out: Path, packs: list[dict], index: bytes, signature: bytes, packs_dir: Path, generated: int) -> tuple[str, str]:
|
||||
if not packs_dir.is_dir():
|
||||
raise PackError(f"{packs_dir} is not a directory")
|
||||
available = {path.name[:-len(".tzst")] for path in packs_dir.glob("*.tzst") if path.is_file()}
|
||||
members = {"index.json": (index, 0o644), "index.json.sig": (signature, 0o644)}
|
||||
for pack in bundle_choice(packs, available):
|
||||
path = packs_dir / f"{pack['id']}.tzst"
|
||||
if path.stat().st_size != pack["asset"]["size"] or sha256_file(path) != pack["asset"]["sha256"]:
|
||||
raise PackError(f"{path} is not the asset the index lists for {pack['id']}")
|
||||
members[f"packs/{pack['id']}.tzst"] = (path.read_bytes(), 0o644)
|
||||
name = bundle_name(generated)
|
||||
archive = compress(tar_bytes(members))
|
||||
write_atomic(out / name, archive)
|
||||
return name, sha256_bytes(archive)
|
||||
|
||||
|
||||
def report(values: dict[str, str]) -> None:
|
||||
path = os.environ.get("GITHUB_OUTPUT")
|
||||
if path:
|
||||
with open(path, "a") as stream:
|
||||
for key, value in values.items():
|
||||
stream.write(f"{key}={value}\n")
|
||||
|
||||
|
||||
def main(argv: list[str] | None = None) -> int:
|
||||
parser = argparse.ArgumentParser(description="Make, sign and bundle the droiddeck-esync pack index from the published pack entries.")
|
||||
parser.add_argument("--entries", required=True)
|
||||
parser.add_argument("--base-url", required=True)
|
||||
parser.add_argument("--key", default="")
|
||||
parser.add_argument("--pubkey", default=str(PUBKEY))
|
||||
parser.add_argument("--out", default="")
|
||||
parser.add_argument("--bundle-packs-dir", default="")
|
||||
parser.add_argument("--revoked", default=str(REVOKED))
|
||||
parser.add_argument("--previous", default="")
|
||||
parser.add_argument("--previous-sig", default="")
|
||||
parser.add_argument("--list-bundle", action="store_true")
|
||||
args = parser.parse_args(argv)
|
||||
try:
|
||||
base_url = args.base_url.rstrip("/")
|
||||
if not base_url.startswith("https://"):
|
||||
raise PackError("--base-url must be an https URL")
|
||||
revoked = read_revoked(Path(args.revoked)) if args.revoked else set()
|
||||
if args.previous_sig and not args.previous:
|
||||
raise PackError("--previous-sig needs --previous")
|
||||
previous_signature = Path(args.previous_sig) if args.previous_sig else None
|
||||
previous_generated, previous, previous_raw = trusted_previous(Path(args.previous), previous_signature, Path(args.pubkey)) \
|
||||
if args.previous else (0, [], None)
|
||||
packs = choose(load_entries(Path(args.entries)), previous, revoked)
|
||||
if args.list_bundle:
|
||||
for pack in bundle_choice(packs):
|
||||
print(f"{pack['flavor']}\t{pack['id']}")
|
||||
return 0
|
||||
if not args.out:
|
||||
raise PackError("--out is required")
|
||||
out = Path(args.out)
|
||||
out.mkdir(parents=True, exist_ok=True)
|
||||
generated = max(int(time.time()), previous_generated + 1)
|
||||
index = build_index(packs, base_url, generated)
|
||||
data = dump_json(index)
|
||||
changed = bool(packs) if previous_raw is None else previous_raw != index["packs"]
|
||||
temp_index = out / f".index.json.tmp-{os.getpid()}"
|
||||
temp_signature = out / f".index.json.sig.tmp-{os.getpid()}"
|
||||
try:
|
||||
temp_index.write_bytes(data)
|
||||
sign(temp_index, temp_signature, Path(args.key) if args.key else None, Path(args.pubkey))
|
||||
signature = temp_signature.read_bytes()
|
||||
os.replace(temp_index, out / "index.json")
|
||||
os.replace(temp_signature, out / "index.json.sig")
|
||||
finally:
|
||||
temp_index.unlink(missing_ok=True)
|
||||
temp_signature.unlink(missing_ok=True)
|
||||
outputs = {"changed": "true" if changed else "false", "generated": str(generated), "index_sha256": sha256_bytes(data)}
|
||||
live = sum(1 for pack in packs if not pack["revoked"])
|
||||
print(f"index.json {outputs['index_sha256']} {live} pack(s), {len(packs) - live} revoked, generated {generated}, {'changed' if changed else 'unchanged'}")
|
||||
if args.bundle_packs_dir:
|
||||
name, digest = bundle(out, packs, data, signature, Path(args.bundle_packs_dir), generated)
|
||||
outputs.update(bundle=name, bundle_sha256=digest)
|
||||
print(f"{name} {digest}")
|
||||
report(outputs)
|
||||
except (PackError, OSError) as e:
|
||||
print(f"make_index: {e}", file=sys.stderr)
|
||||
return 1
|
||||
return 0
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
raise SystemExit(main())
|
||||
@@ -1,367 +0,0 @@
|
||||
#!/usr/bin/env python3
|
||||
from __future__ import annotations
|
||||
|
||||
import argparse
|
||||
import functools
|
||||
import hashlib
|
||||
import importlib.machinery
|
||||
import importlib.util
|
||||
import io
|
||||
import json
|
||||
import os
|
||||
import re
|
||||
import subprocess
|
||||
import sys
|
||||
import tarfile
|
||||
from pathlib import Path
|
||||
|
||||
HERE = Path(__file__).resolve().parent
|
||||
ROOT = HERE.parents[1]
|
||||
GUEST = ROOT / "tools/linuxfs/overlay/usr/local/bin/droiddeck-esync"
|
||||
PATCHES = HERE / "patches"
|
||||
REVOKED = HERE / "revoked.txt"
|
||||
NTDLL = "files/lib/wine/aarch64-unix/ntdll.so"
|
||||
WINESERVER = "files/bin-arm64/wineserver"
|
||||
BINARIES = (NTDLL, WINESERVER)
|
||||
COPY = ("files/bin-arm64/wine", "files/lib/wine/aarch64-unix/wine", "files/lib/wine/aarch64-unix/wine-preloader")
|
||||
HEADERS = ("server_protocol.h", "request_handlers.h", "request_trace.h")
|
||||
FLAVORS = ("valve", "ge", "cachyos")
|
||||
SOURCE_KEYS = ("repo", "ref", "commit", "wine_commit", "sdk_image")
|
||||
ENTRY_KEYS = ("id", "flavor", "rev", "version", "version_line", "stock", "exports", "source_match", "files", "protocol", "source", "patch")
|
||||
PACK_ID = re.compile(r"[A-Za-z0-9][A-Za-z0-9._-]{0,127}")
|
||||
SERIES = re.compile(r"[A-Za-z0-9][A-Za-z0-9._-]*")
|
||||
SHA256 = re.compile(r"[0-9a-f]{64}")
|
||||
EPOCH = re.compile(r"[0-9]{1,12}")
|
||||
PROTOCOL = re.compile(rb"^#define SERVER_PROTOCOL_VERSION ([0-9]+)[ \t]*$", re.M)
|
||||
BUILTIN_ESYNC = b"esync: up and running"
|
||||
ELF_MAGIC = b"\x7fELF"
|
||||
GUEST_MODULE = "droiddeck_esync_tools"
|
||||
|
||||
|
||||
class PackError(RuntimeError):
|
||||
pass
|
||||
|
||||
|
||||
@functools.lru_cache(maxsize=None)
|
||||
def guest():
|
||||
loader = importlib.machinery.SourceFileLoader(GUEST_MODULE, str(GUEST))
|
||||
module = importlib.util.module_from_spec(importlib.util.spec_from_loader(GUEST_MODULE, loader))
|
||||
sys.modules[GUEST_MODULE] = module
|
||||
write_bytecode = sys.dont_write_bytecode
|
||||
sys.dont_write_bytecode = True
|
||||
try:
|
||||
loader.exec_module(module)
|
||||
except Exception as e:
|
||||
sys.modules.pop(GUEST_MODULE, None)
|
||||
raise PackError(f"cannot load {GUEST}: {e}") from e
|
||||
finally:
|
||||
sys.dont_write_bytecode = write_bytecode
|
||||
return module
|
||||
|
||||
|
||||
def sha256_bytes(data: bytes) -> str:
|
||||
return hashlib.sha256(data).hexdigest()
|
||||
|
||||
|
||||
def sha256_file(path: Path) -> str:
|
||||
digest = hashlib.sha256()
|
||||
with path.open("rb") as stream:
|
||||
for block in iter(lambda: stream.read(1 << 20), b""):
|
||||
digest.update(block)
|
||||
return digest.hexdigest()
|
||||
|
||||
|
||||
def slug(text: str) -> str:
|
||||
return re.sub(r"[^A-Za-z0-9._-]", "-", text)
|
||||
|
||||
|
||||
def dump_json(value) -> bytes:
|
||||
return (json.dumps(value, indent=1, sort_keys=True, ensure_ascii=True) + "\n").encode()
|
||||
|
||||
|
||||
def write_atomic(path: Path, data: bytes) -> None:
|
||||
temp = path.with_name(f".{path.name}.tmp-{os.getpid()}")
|
||||
try:
|
||||
with temp.open("wb") as stream:
|
||||
stream.write(data)
|
||||
stream.flush()
|
||||
os.fsync(stream.fileno())
|
||||
os.replace(temp, path)
|
||||
except BaseException:
|
||||
temp.unlink(missing_ok=True)
|
||||
raise
|
||||
|
||||
|
||||
def read_revoked(path: Path | None) -> set[str]:
|
||||
if path is None:
|
||||
return set()
|
||||
try:
|
||||
text = path.read_text()
|
||||
except OSError as e:
|
||||
raise PackError(f"cannot read the revocation list {path}: {e}") from e
|
||||
revoked = set()
|
||||
for raw in text.splitlines():
|
||||
line = raw.strip()
|
||||
if not line or line.startswith("#"):
|
||||
continue
|
||||
ident = line.split()[0]
|
||||
if not PACK_ID.fullmatch(ident):
|
||||
raise PackError(f"{path}: {ident!r} is not a pack id")
|
||||
revoked.add(ident)
|
||||
return revoked
|
||||
|
||||
|
||||
def tar_bytes(members: dict[str, tuple[bytes, int]]) -> bytes:
|
||||
buffer = io.BytesIO()
|
||||
with tarfile.open(fileobj=buffer, mode="w", format=tarfile.USTAR_FORMAT) as tar:
|
||||
for name in sorted(members):
|
||||
data, mode = members[name]
|
||||
info = tarfile.TarInfo(name)
|
||||
info.size = len(data)
|
||||
info.mode = mode
|
||||
info.mtime = 0
|
||||
info.uid = 0
|
||||
info.gid = 0
|
||||
info.uname = ""
|
||||
info.gname = ""
|
||||
tar.addfile(info, io.BytesIO(data))
|
||||
return buffer.getvalue()
|
||||
|
||||
|
||||
def zstd(data: bytes, *args: str) -> bytes:
|
||||
try:
|
||||
result = subprocess.run(["zstd", "-q", *args], input=data, stdout=subprocess.PIPE, stderr=subprocess.PIPE, check=False)
|
||||
except FileNotFoundError as e:
|
||||
raise PackError("the zstd command is not installed") from e
|
||||
if result.returncode != 0:
|
||||
raise PackError(f"zstd {' '.join(args)} failed: {result.stderr.decode(errors='replace').strip()}")
|
||||
return result.stdout
|
||||
|
||||
|
||||
def compress(data: bytes) -> bytes:
|
||||
return zstd(data, "-19", "-T1", "-c")
|
||||
|
||||
|
||||
def unpack(archive: bytes) -> dict[str, tuple[bytes, int]]:
|
||||
members = {}
|
||||
try:
|
||||
with tarfile.open(fileobj=io.BytesIO(zstd(archive, "-d", "-c")), mode="r:") as tar:
|
||||
for info in tar:
|
||||
if not info.isreg() or info.name in members:
|
||||
raise PackError(f"unexpected entry {info.name!r} in the archive")
|
||||
members[info.name] = (tar.extractfile(info).read(), info.mode)
|
||||
except tarfile.TarError as e:
|
||||
raise PackError(f"the archive does not read back: {e}") from e
|
||||
return members
|
||||
|
||||
|
||||
def binary(base: Path, rel: str) -> Path:
|
||||
path = base / rel
|
||||
if path.is_symlink() or not path.is_file():
|
||||
raise PackError(f"{path} is not a regular file")
|
||||
with path.open("rb") as stream:
|
||||
if stream.read(len(ELF_MAGIC)) != ELF_MAGIC:
|
||||
raise PackError(f"{path} is not an ELF file")
|
||||
return path
|
||||
|
||||
|
||||
def exports_hash(path: Path) -> str:
|
||||
try:
|
||||
value = guest().exports_hash(path)
|
||||
except PackError:
|
||||
raise
|
||||
except Exception as e:
|
||||
raise PackError(f"{path}: cannot read its exported symbols: {e}") from e
|
||||
if not isinstance(value, str) or not SHA256.fullmatch(value):
|
||||
raise PackError(f"{path}: has no exported symbols")
|
||||
return value
|
||||
|
||||
|
||||
def parse_version_line(line: str) -> tuple[int, str]:
|
||||
fields = line.split()
|
||||
if "\n" in line or len(fields) < 2 or not EPOCH.fullmatch(fields[0]):
|
||||
raise PackError(f"version line {line!r} is not '<build epoch> <version>'")
|
||||
token = guest().version_token(line)
|
||||
if not isinstance(token, str) or not token:
|
||||
raise PackError(f"version line {line!r} has no version token")
|
||||
return int(fields[0]), token
|
||||
|
||||
|
||||
def parse_source(text: str) -> dict[str, str]:
|
||||
try:
|
||||
source = json.loads(text)
|
||||
except ValueError as e:
|
||||
raise PackError(f"--source-json is not JSON: {e}") from e
|
||||
if not isinstance(source, dict) or not all(isinstance(key, str) and isinstance(value, str) for key, value in source.items()):
|
||||
raise PackError("--source-json must be an object of strings")
|
||||
missing = [key for key in SOURCE_KEYS if not source.get(key)]
|
||||
if missing:
|
||||
raise PackError(f"--source-json lacks {', '.join(missing)}")
|
||||
return source
|
||||
|
||||
|
||||
def patch_digest(directory: Path) -> str:
|
||||
patches = sorted(path for path in directory.glob("*.patch") if path.is_file())
|
||||
if not patches:
|
||||
raise PackError(f"{directory} holds no *.patch files")
|
||||
digest = hashlib.sha256()
|
||||
for path in patches:
|
||||
digest.update(f"{path.name}\0{sha256_file(path)}\n".encode())
|
||||
return digest.hexdigest()
|
||||
|
||||
|
||||
def protocol_version(control: Path, patched: Path) -> int:
|
||||
for name in HEADERS:
|
||||
before, after = control / name, patched / name
|
||||
if not before.is_file() or not after.is_file():
|
||||
raise PackError(f"{name} is missing from the control or the patched build")
|
||||
if before.read_bytes() != after.read_bytes():
|
||||
raise PackError(f"the patch changes {name}: the droiddeck-esync patch must not change the wineserver protocol")
|
||||
found = PROTOCOL.findall((control / HEADERS[0]).read_bytes())
|
||||
if len(found) != 1:
|
||||
raise PackError("server_protocol.h does not define SERVER_PROTOCOL_VERSION once")
|
||||
version = int(found[0])
|
||||
stamp = control / "protocol"
|
||||
if stamp.is_file() and stamp.read_text().strip() != str(version):
|
||||
raise PackError(f"{stamp} disagrees with server_protocol.h ({version})")
|
||||
return version
|
||||
|
||||
|
||||
def make_pack(
|
||||
flavor: str,
|
||||
rev: int,
|
||||
stock_dir: Path | None,
|
||||
version_line: str,
|
||||
control: Path,
|
||||
patched: Path,
|
||||
source: dict[str, str],
|
||||
series: str,
|
||||
out: Path,
|
||||
source_match: bool,
|
||||
patch_dir: Path | None = None,
|
||||
allow_unreproduced: bool = False,
|
||||
) -> dict:
|
||||
if flavor not in FLAVORS:
|
||||
raise PackError(f"unknown flavor {flavor!r}")
|
||||
if type(rev) is not int or rev < 1:
|
||||
raise PackError("--rev must be a positive number")
|
||||
if not SERIES.fullmatch(series):
|
||||
raise PackError(f"{series!r} is not a patch series name")
|
||||
if stock_dir is None and not source_match:
|
||||
raise PackError("without --stock-dir a pack can only match by source: pass --source-match")
|
||||
if stock_dir is not None and source_match:
|
||||
raise PackError("a pack made against stock binaries matches them exactly: drop --source-match")
|
||||
patch_dir = patch_dir or PATCHES / series
|
||||
if not patch_dir.is_dir():
|
||||
raise PackError(f"the patch series {patch_dir} does not exist")
|
||||
version_line = version_line.strip()
|
||||
if stock_dir is not None:
|
||||
stock_line = guest().version_line(stock_dir)
|
||||
if stock_line and version_line and stock_line != version_line:
|
||||
raise PackError(f"{stock_dir}/version says {stock_line!r}, not {version_line!r}")
|
||||
version_line = version_line or stock_line
|
||||
epoch, token = parse_version_line(version_line)
|
||||
|
||||
stock_paths = {rel: binary(stock_dir or control, rel) for rel in BINARIES}
|
||||
control_paths = {rel: binary(control, rel) for rel in BINARIES}
|
||||
patched_paths = {rel: binary(patched, rel) for rel in BINARIES}
|
||||
if BUILTIN_ESYNC in stock_paths[WINESERVER].read_bytes():
|
||||
raise PackError(f"{stock_paths[WINESERVER]} has esync built in and needs no pack")
|
||||
stock = {rel: sha256_file(path) for rel, path in stock_paths.items()}
|
||||
built = {rel: sha256_file(path) for rel, path in control_paths.items()}
|
||||
files = {rel: sha256_file(path) for rel, path in patched_paths.items()}
|
||||
for rel in BINARIES:
|
||||
if files[rel] == built[rel]:
|
||||
raise PackError(f"the patch left {rel} unchanged")
|
||||
|
||||
exports = exports_hash(stock_paths[NTDLL])
|
||||
control_exports = exports_hash(control_paths[NTDLL])
|
||||
if exports_hash(patched_paths[NTDLL]) != control_exports:
|
||||
raise PackError("the patch changes the symbols ntdll.so exports")
|
||||
if exports != control_exports:
|
||||
raise PackError("the control build of ntdll.so exports other symbols than the stock one: the wine source does not match this release")
|
||||
protocol = protocol_version(control, patched)
|
||||
if stock_dir is not None:
|
||||
for rel in BINARIES:
|
||||
state = "reproduces" if stock[rel] == built[rel] else "differs from"
|
||||
print(f"make_pack: the control build {state} the stock {rel}", file=sys.stderr)
|
||||
unreproduced = [rel for rel in BINARIES if stock[rel] != built[rel]]
|
||||
if unreproduced and not allow_unreproduced:
|
||||
raise PackError(f"the control build does not reproduce the stock {', '.join(unreproduced)}: the patched files would differ "
|
||||
"from the release in more than the patch (check the build directory and the SDK image, or pass --allow-unreproduced)")
|
||||
|
||||
pack_id = f"{flavor}-{slug(token)}-{epoch}-{stock[NTDLL][:12]}-r{rev}"
|
||||
if not PACK_ID.fullmatch(pack_id):
|
||||
raise PackError(f"{pack_id!r} is not a valid pack id")
|
||||
pack = {
|
||||
"format": 1,
|
||||
"id": pack_id,
|
||||
"flavor": flavor,
|
||||
"rev": rev,
|
||||
"version": token,
|
||||
"version_line": version_line,
|
||||
"stock": stock,
|
||||
"exports": exports,
|
||||
"source_match": source_match,
|
||||
"files": files,
|
||||
"copy": list(COPY),
|
||||
"protocol": protocol,
|
||||
"source": dict(source),
|
||||
"patch": {"series": series, "sha256": patch_digest(patch_dir)},
|
||||
}
|
||||
members = {
|
||||
"pack.json": (dump_json(pack), 0o644),
|
||||
NTDLL: (patched_paths[NTDLL].read_bytes(), 0o755),
|
||||
WINESERVER: (patched_paths[WINESERVER].read_bytes(), 0o755),
|
||||
}
|
||||
archive = compress(tar_bytes(members))
|
||||
if unpack(archive) != members:
|
||||
raise PackError("the archive does not read back as written")
|
||||
entry = {key: pack[key] for key in ENTRY_KEYS}
|
||||
entry["asset"] = {"sha256": sha256_bytes(archive), "size": len(archive)}
|
||||
entry["revoked"] = False
|
||||
out.mkdir(parents=True, exist_ok=True)
|
||||
write_atomic(out / f"{pack_id}.tzst", archive)
|
||||
write_atomic(out / f"{pack_id}.json", dump_json(entry))
|
||||
return entry
|
||||
|
||||
|
||||
def main(argv: list[str] | None = None) -> int:
|
||||
parser = argparse.ArgumentParser(description="Make a droiddeck-esync pack from a control and a patched wine build of one Proton release.")
|
||||
parser.add_argument("--flavor", required=True, choices=FLAVORS)
|
||||
parser.add_argument("--rev", required=True, type=int)
|
||||
parser.add_argument("--stock-dir", default="")
|
||||
parser.add_argument("--version-line", default="")
|
||||
parser.add_argument("--control", required=True)
|
||||
parser.add_argument("--patched", required=True)
|
||||
parser.add_argument("--source-json", required=True)
|
||||
parser.add_argument("--patch-series", required=True)
|
||||
parser.add_argument("--patch-dir", default="")
|
||||
parser.add_argument("--out", required=True)
|
||||
parser.add_argument("--source-match", action="store_true")
|
||||
parser.add_argument("--allow-unreproduced", action="store_true")
|
||||
args = parser.parse_args(argv)
|
||||
try:
|
||||
entry = make_pack(
|
||||
flavor=args.flavor,
|
||||
rev=args.rev,
|
||||
stock_dir=Path(args.stock_dir) if args.stock_dir else None,
|
||||
version_line=args.version_line,
|
||||
control=Path(args.control),
|
||||
patched=Path(args.patched),
|
||||
source=parse_source(args.source_json),
|
||||
series=args.patch_series,
|
||||
out=Path(args.out),
|
||||
source_match=args.source_match,
|
||||
patch_dir=Path(args.patch_dir) if args.patch_dir else None,
|
||||
allow_unreproduced=args.allow_unreproduced,
|
||||
)
|
||||
except (PackError, OSError) as e:
|
||||
print(f"make_pack: {e}", file=sys.stderr)
|
||||
return 1
|
||||
print(entry["id"])
|
||||
return 0
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
raise SystemExit(main())
|
||||
File diff suppressed because it is too large.
Load diff
File diff suppressed because it is too large.
Load diff
@@ -0,0 +1,4 @@
|
||||
SYNC_BUNDLE_REPO=Droid-Deck/DroidDeck-Components
|
||||
SYNC_BUNDLE_TAG=droiddeck-esync-index
|
||||
SYNC_BUNDLE_ASSET=bundle-20261004-142603.tzst
|
||||
SYNC_BUNDLE_SHA256=7e311e92444f0709de7779ef5334708511345d60556aa429e6761b86d711a9b2
|
||||
Whitespace-only changes.
@@ -1,62 +0,0 @@
|
||||
#!/bin/bash
|
||||
set -euo pipefail
|
||||
|
||||
if [ $# -ne 4 ]; then
|
||||
echo "usage: $0 <proton-dir> <pack.tzst> <esstress.exe> <work-dir>" >&2
|
||||
exit 2
|
||||
fi
|
||||
tool=$(realpath "$1")
|
||||
archive=$(realpath "$2")
|
||||
exe=$(realpath "$3")
|
||||
work=$(realpath -m "$4")
|
||||
here=$(cd "$(dirname "$0")" && pwd)
|
||||
guest=$here/../linuxfs/overlay/usr/local/bin/droiddeck-esync
|
||||
rm -rf "$work"
|
||||
mkdir -p "$work/pack"
|
||||
tar --zstd -xf "$archive" -C "$work/pack"
|
||||
python3 "$guest" build-shadow "$tool" "$work/pack" "$work/dist" >/dev/null
|
||||
[ -e "$work/dist/files/bin" ] || ln -s bin-arm64 "$work/dist/files/bin"
|
||||
export WINEDEBUG=-all WINEDLLOVERRIDES="mscoree,mshtml="
|
||||
|
||||
run() {
|
||||
local mode=$1 bin=$2 want=$3
|
||||
shift 3
|
||||
local prefix=$work/prefix-$mode
|
||||
mkdir -p "$prefix"
|
||||
(
|
||||
export WINEPREFIX=$prefix WINESERVER=$bin/wineserver "$@"
|
||||
timeout "${BOOT_TIMEOUT:-900}" "$bin/wine" wineboot -i > "$work/$mode-boot.log" 2>&1 || true
|
||||
"$bin/wineserver" -w || true
|
||||
if ! grep -q "$want" "$work/$mode-boot.log"; then
|
||||
echo "$mode: wine never said \"$want\""
|
||||
tail -n 30 "$work/$mode-boot.log"
|
||||
exit 1
|
||||
fi
|
||||
cp "$exe" "$prefix/drive_c/esstress.exe"
|
||||
status=0
|
||||
timeout "${STRESS_TIMEOUT:-1800}" "$bin/wine" 'C:\esstress.exe' > "$work/$mode-stress.log" 2>&1 || status=$?
|
||||
"$bin/wineserver" -k 2>/dev/null || true
|
||||
if ! grep -q '^esstress:' "$work/$mode-stress.log"; then
|
||||
echo "$mode: esstress did not finish (status $status)"
|
||||
tail -n 30 "$work/$mode-stress.log"
|
||||
exit 1
|
||||
fi
|
||||
grep -o '^FAIL [^ ]*:[0-9]*:' "$work/$mode-stress.log" | sort -u > "$work/$mode-failures" || true
|
||||
echo "$mode: $(grep -E '^esstress:' "$work/$mode-stress.log" | tail -n 1)"
|
||||
)
|
||||
}
|
||||
|
||||
if ! run stock "$tool/files/bin-arm64" "server-side synchronization" PROTON_NO_NTSYNC=1 WINEESYNC=0 WINEFSYNC=0; then
|
||||
echo "stock Proton does not run here either; the pack cannot be judged on this machine"
|
||||
exit 3
|
||||
fi
|
||||
run esync "$work/dist/files/bin-arm64" "esync: up and running" PROTON_NO_NTSYNC=1 WINEESYNC=1 WINEFSYNC=0
|
||||
if [ -s "$work/stock-failures" ]; then
|
||||
echo "stock fails these as well, so they do not count against the pack: $(tr '\n' ' ' < "$work/stock-failures")"
|
||||
fi
|
||||
new=$(comm -13 "$work/stock-failures" "$work/esync-failures")
|
||||
if [ -n "$new" ]; then
|
||||
echo "esync: fails checks stock passes:"
|
||||
grep -F "$new" "$work/esync-stress.log" || echo "$new"
|
||||
exit 1
|
||||
fi
|
||||
@@ -1,618 +0,0 @@
|
||||
#include <windows.h>
|
||||
#include <winternl.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
static int failures;
|
||||
#define CHECK(c, ...) do { if (!(c)) { failures++; printf("FAIL %s:%d: ", __FILE__, __LINE__); printf(__VA_ARGS__); printf("\n"); fflush(stdout); } } while (0)
|
||||
|
||||
static volatile LONG counter;
|
||||
static HANDLE mutex, sem, ev_auto, ev_manual, start_ev;
|
||||
static volatile LONG stop;
|
||||
|
||||
static DWORD WINAPI mutex_worker(void *arg)
|
||||
{
|
||||
int i;
|
||||
WaitForSingleObject(start_ev, INFINITE);
|
||||
for (i = 0; i < 20000; i++)
|
||||
{
|
||||
DWORD r = WaitForSingleObject(mutex, INFINITE);
|
||||
LONG v;
|
||||
if (r != WAIT_OBJECT_0) { CHECK(0, "mutex wait %lu", r); break; }
|
||||
v = counter;
|
||||
if (i % 7 == 0) WaitForSingleObject(mutex, 0), ReleaseMutex(mutex);
|
||||
counter = v + 1;
|
||||
ReleaseMutex(mutex);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void test_mutex_contention(void)
|
||||
{
|
||||
HANDLE th[8];
|
||||
int i;
|
||||
counter = 0;
|
||||
mutex = CreateMutexA(NULL, FALSE, NULL);
|
||||
start_ev = CreateEventA(NULL, TRUE, FALSE, NULL);
|
||||
for (i = 0; i < 8; i++) th[i] = CreateThread(NULL, 0, mutex_worker, NULL, 0, NULL);
|
||||
SetEvent(start_ev);
|
||||
WaitForMultipleObjects(8, th, TRUE, INFINITE);
|
||||
CHECK(counter == 8 * 20000, "mutex counter %ld", counter);
|
||||
for (i = 0; i < 8; i++) CloseHandle(th[i]);
|
||||
CloseHandle(mutex);
|
||||
CloseHandle(start_ev);
|
||||
printf("mutex_contention ok counter=%ld\n", counter);
|
||||
}
|
||||
|
||||
static volatile LONG produced, consumed;
|
||||
|
||||
static DWORD WINAPI sem_producer(void *arg)
|
||||
{
|
||||
int i;
|
||||
for (i = 0; i < 50000; i++)
|
||||
{
|
||||
LONG prev;
|
||||
while (!ReleaseSemaphore(sem, 1, &prev))
|
||||
{
|
||||
CHECK(GetLastError() == ERROR_TOO_MANY_POSTS, "release err %lu", GetLastError());
|
||||
Sleep(0);
|
||||
}
|
||||
InterlockedIncrement(&produced);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
static DWORD WINAPI sem_consumer(void *arg)
|
||||
{
|
||||
for (;;)
|
||||
{
|
||||
DWORD r = WaitForSingleObject(sem, 2000);
|
||||
if (r == WAIT_TIMEOUT) break;
|
||||
CHECK(r == WAIT_OBJECT_0, "sem wait %lu", r);
|
||||
InterlockedIncrement(&consumed);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void test_semaphore(void)
|
||||
{
|
||||
HANDLE th[8];
|
||||
LONG prev;
|
||||
int i;
|
||||
produced = consumed = 0;
|
||||
sem = CreateSemaphoreA(NULL, 0, 16, NULL);
|
||||
for (i = 0; i < 4; i++) th[i] = CreateThread(NULL, 0, sem_producer, NULL, 0, NULL);
|
||||
for (i = 4; i < 8; i++) th[i] = CreateThread(NULL, 0, sem_consumer, NULL, 0, NULL);
|
||||
WaitForMultipleObjects(8, th, TRUE, INFINITE);
|
||||
CHECK(produced == 200000 && consumed == 200000, "sem produced %ld consumed %ld", produced, consumed);
|
||||
CHECK(!ReleaseSemaphore(sem, 17, &prev) && GetLastError() == ERROR_TOO_MANY_POSTS, "limit");
|
||||
CHECK(ReleaseSemaphore(sem, 16, &prev) && prev == 0, "prev %ld", prev);
|
||||
CHECK(!ReleaseSemaphore(sem, 1, &prev), "over max");
|
||||
for (i = 0; i < 8; i++) CloseHandle(th[i]);
|
||||
CloseHandle(sem);
|
||||
printf("semaphore ok %ld/%ld\n", produced, consumed);
|
||||
}
|
||||
|
||||
static volatile LONG auto_hits;
|
||||
|
||||
static DWORD WINAPI auto_waiter(void *arg)
|
||||
{
|
||||
while (!stop)
|
||||
{
|
||||
DWORD r = WaitForSingleObject(ev_auto, 50);
|
||||
if (r == WAIT_OBJECT_0) InterlockedIncrement(&auto_hits);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void test_auto_event(void)
|
||||
{
|
||||
HANDLE th[6];
|
||||
int i;
|
||||
LONG expected = 0;
|
||||
stop = 0; auto_hits = 0;
|
||||
ev_auto = CreateEventA(NULL, FALSE, FALSE, NULL);
|
||||
for (i = 0; i < 6; i++) th[i] = CreateThread(NULL, 0, auto_waiter, NULL, 0, NULL);
|
||||
for (i = 0; i < 30000; i++)
|
||||
{
|
||||
LONG before = auto_hits;
|
||||
SetEvent(ev_auto);
|
||||
expected++;
|
||||
while (auto_hits == before) SwitchToThread();
|
||||
}
|
||||
stop = 1;
|
||||
WaitForMultipleObjects(6, th, TRUE, INFINITE);
|
||||
CHECK(auto_hits == expected, "auto hits %ld expected %ld", auto_hits, expected);
|
||||
CHECK(WaitForSingleObject(ev_auto, 0) == WAIT_TIMEOUT, "auto event left signaled");
|
||||
SetEvent(ev_auto); SetEvent(ev_auto);
|
||||
CHECK(WaitForSingleObject(ev_auto, 0) == WAIT_OBJECT_0, "auto set");
|
||||
CHECK(WaitForSingleObject(ev_auto, 0) == WAIT_TIMEOUT, "auto coalesce");
|
||||
for (i = 0; i < 6; i++) CloseHandle(th[i]);
|
||||
CloseHandle(ev_auto);
|
||||
printf("auto_event ok hits=%ld\n", auto_hits);
|
||||
}
|
||||
|
||||
static volatile LONG manual_seen;
|
||||
|
||||
static DWORD WINAPI manual_waiter(void *arg)
|
||||
{
|
||||
DWORD r = WaitForSingleObject(ev_manual, 10000);
|
||||
if (r == WAIT_OBJECT_0) InterlockedIncrement(&manual_seen);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void test_manual_event(void)
|
||||
{
|
||||
HANDLE th[16];
|
||||
int i, round;
|
||||
ev_manual = CreateEventA(NULL, TRUE, FALSE, NULL);
|
||||
for (round = 0; round < 50; round++)
|
||||
{
|
||||
manual_seen = 0;
|
||||
ResetEvent(ev_manual);
|
||||
for (i = 0; i < 16; i++) th[i] = CreateThread(NULL, 0, manual_waiter, NULL, 0, NULL);
|
||||
Sleep(2);
|
||||
SetEvent(ev_manual);
|
||||
WaitForMultipleObjects(16, th, TRUE, INFINITE);
|
||||
CHECK(manual_seen == 16, "manual round %d seen %ld", round, manual_seen);
|
||||
for (i = 0; i < 16; i++) CloseHandle(th[i]);
|
||||
}
|
||||
for (i = 0; i < 20000; i++)
|
||||
{
|
||||
SetEvent(ev_manual);
|
||||
if (i & 1) ResetEvent(ev_manual);
|
||||
}
|
||||
CHECK(WaitForSingleObject(ev_manual, 0) == WAIT_TIMEOUT, "manual final reset");
|
||||
SetEvent(ev_manual);
|
||||
CHECK(WaitForSingleObject(ev_manual, 0) == WAIT_OBJECT_0, "manual stays");
|
||||
CHECK(WaitForSingleObject(ev_manual, 0) == WAIT_OBJECT_0, "manual stays 2");
|
||||
CloseHandle(ev_manual);
|
||||
printf("manual_event ok\n");
|
||||
}
|
||||
|
||||
static HANDLE wa_objs[3];
|
||||
static volatile LONG wa_count;
|
||||
|
||||
static DWORD WINAPI wait_all_worker(void *arg)
|
||||
{
|
||||
int i;
|
||||
for (i = 0; i < 3000; i++)
|
||||
{
|
||||
DWORD r = WaitForMultipleObjects(3, wa_objs, TRUE, 5000);
|
||||
if (r != WAIT_OBJECT_0) { CHECK(0, "wait all %lu", r); break; }
|
||||
InterlockedIncrement(&wa_count);
|
||||
ReleaseMutex(wa_objs[0]);
|
||||
ReleaseSemaphore(wa_objs[1], 1, NULL);
|
||||
SetEvent(wa_objs[2]);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void test_wait_all(void)
|
||||
{
|
||||
HANDLE th[6], dup[2];
|
||||
int i;
|
||||
DWORD r;
|
||||
wa_count = 0;
|
||||
wa_objs[0] = CreateMutexA(NULL, FALSE, NULL);
|
||||
wa_objs[1] = CreateSemaphoreA(NULL, 1, 1, NULL);
|
||||
wa_objs[2] = CreateEventA(NULL, FALSE, TRUE, NULL);
|
||||
for (i = 0; i < 6; i++) th[i] = CreateThread(NULL, 0, wait_all_worker, NULL, 0, NULL);
|
||||
WaitForMultipleObjects(6, th, TRUE, INFINITE);
|
||||
CHECK(wa_count == 18000, "wait all count %ld", wa_count);
|
||||
dup[0] = wa_objs[2];
|
||||
DuplicateHandle(GetCurrentProcess(), wa_objs[2], GetCurrentProcess(), &dup[1], 0, FALSE, DUPLICATE_SAME_ACCESS);
|
||||
r = WaitForMultipleObjects(2, dup, TRUE, 0);
|
||||
CHECK(r == WAIT_FAILED && GetLastError() == ERROR_INVALID_PARAMETER, "dup wait all %lu %lu", r, GetLastError());
|
||||
CloseHandle(dup[1]);
|
||||
for (i = 0; i < 6; i++) CloseHandle(th[i]);
|
||||
for (i = 0; i < 3; i++) CloseHandle(wa_objs[i]);
|
||||
printf("wait_all ok %ld\n", wa_count);
|
||||
}
|
||||
|
||||
static DWORD WINAPI hold_and_die(void *arg)
|
||||
{
|
||||
WaitForSingleObject((HANDLE)arg, INFINITE);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void test_abandoned(void)
|
||||
{
|
||||
HANDLE m = CreateMutexA(NULL, FALSE, NULL);
|
||||
HANDLE th = CreateThread(NULL, 0, hold_and_die, m, 0, NULL);
|
||||
HANDLE objs[2];
|
||||
DWORD r;
|
||||
WaitForSingleObject(th, INFINITE);
|
||||
r = WaitForSingleObject(m, 1000);
|
||||
CHECK(r == WAIT_ABANDONED, "abandoned %lu", r);
|
||||
CHECK(ReleaseMutex(m), "release after abandon");
|
||||
th = CreateThread(NULL, 0, hold_and_die, m, 0, NULL);
|
||||
WaitForSingleObject(th, INFINITE);
|
||||
objs[0] = CreateEventA(NULL, TRUE, TRUE, NULL);
|
||||
objs[1] = m;
|
||||
r = WaitForMultipleObjects(2, objs, TRUE, 1000);
|
||||
CHECK(r == WAIT_ABANDONED_0, "abandoned all %lu", r);
|
||||
ReleaseMutex(m);
|
||||
r = WaitForMultipleObjects(2, objs, FALSE, 1000);
|
||||
CHECK(r == WAIT_OBJECT_0, "any after %lu", r);
|
||||
CloseHandle(th); CloseHandle(objs[0]); CloseHandle(m);
|
||||
printf("abandoned ok\n");
|
||||
}
|
||||
|
||||
static volatile LONG apc_ran;
|
||||
static void CALLBACK apc_proc(ULONG_PTR p) { InterlockedIncrement(&apc_ran); }
|
||||
|
||||
static HANDLE apc_ready;
|
||||
|
||||
static DWORD WINAPI alert_waiter(void *arg)
|
||||
{
|
||||
SetEvent(apc_ready);
|
||||
return WaitForSingleObjectEx((HANDLE)arg, 5000, TRUE);
|
||||
}
|
||||
|
||||
static void test_apc(void)
|
||||
{
|
||||
HANDLE ev = CreateEventA(NULL, TRUE, FALSE, NULL);
|
||||
HANDLE th;
|
||||
DWORD r, code;
|
||||
int i;
|
||||
apc_ready = CreateEventA(NULL, FALSE, FALSE, NULL);
|
||||
for (i = 0; i < 200; i++)
|
||||
{
|
||||
apc_ran = 0;
|
||||
th = CreateThread(NULL, 0, alert_waiter, ev, 0, NULL);
|
||||
WaitForSingleObject(apc_ready, INFINITE);
|
||||
if (i & 1) Sleep(1);
|
||||
QueueUserAPC(apc_proc, th, 0);
|
||||
WaitForSingleObject(th, INFINITE);
|
||||
GetExitCodeThread(th, &code);
|
||||
CHECK(code == WAIT_IO_COMPLETION && apc_ran == 1, "apc round %d code %lu ran %ld", i, code, apc_ran);
|
||||
CloseHandle(th);
|
||||
}
|
||||
apc_ran = 0;
|
||||
QueueUserAPC(apc_proc, GetCurrentThread(), 0);
|
||||
r = SleepEx(1000, TRUE);
|
||||
CHECK(r == WAIT_IO_COMPLETION && apc_ran == 1, "sleepex %lu %ld", r, apc_ran);
|
||||
r = SleepEx(10, TRUE);
|
||||
CHECK(r == 0, "sleepex timeout %lu", r);
|
||||
QueueUserAPC(apc_proc, GetCurrentThread(), 0);
|
||||
r = WaitForSingleObjectEx(ev, 0, FALSE);
|
||||
CHECK(r == WAIT_TIMEOUT, "non alertable %lu", r);
|
||||
r = WaitForSingleObjectEx(ev, 0, TRUE);
|
||||
CHECK(r == WAIT_IO_COMPLETION, "alertable pending %lu", r);
|
||||
CloseHandle(ev);
|
||||
printf("apc ok\n");
|
||||
}
|
||||
|
||||
static DWORD WINAPI close_waiter(void *arg)
|
||||
{
|
||||
return WaitForSingleObject((HANDLE)arg, 300);
|
||||
}
|
||||
|
||||
static void test_close_while_waiting(void)
|
||||
{
|
||||
int i;
|
||||
for (i = 0; i < 300; i++)
|
||||
{
|
||||
HANDLE ev = CreateEventA(NULL, TRUE, FALSE, NULL), ev2, th;
|
||||
DWORD code;
|
||||
th = CreateThread(NULL, 0, close_waiter, ev, 0, NULL);
|
||||
Sleep(0);
|
||||
CloseHandle(ev);
|
||||
ev2 = CreateEventA(NULL, TRUE, TRUE, NULL);
|
||||
WaitForSingleObject(th, INFINITE);
|
||||
GetExitCodeThread(th, &code);
|
||||
CHECK(code == WAIT_TIMEOUT || code == WAIT_FAILED || code == WAIT_OBJECT_0, "close round %d code %lu", i, code);
|
||||
CHECK(WaitForSingleObject(ev2, 0) == WAIT_OBJECT_0, "reused handle state");
|
||||
CloseHandle(ev2);
|
||||
CloseHandle(th);
|
||||
}
|
||||
printf("close_while_waiting ok\n");
|
||||
}
|
||||
|
||||
static void test_pulse(void)
|
||||
{
|
||||
HANDLE ev = CreateEventA(NULL, TRUE, FALSE, NULL), th[4];
|
||||
DWORD code;
|
||||
int i, woke = 0;
|
||||
for (i = 0; i < 4; i++) th[i] = CreateThread(NULL, 0, close_waiter, ev, 0, NULL);
|
||||
Sleep(50);
|
||||
PulseEvent(ev);
|
||||
WaitForMultipleObjects(4, th, TRUE, INFINITE);
|
||||
for (i = 0; i < 4; i++) { GetExitCodeThread(th[i], &code); if (code == WAIT_OBJECT_0) woke++; CloseHandle(th[i]); }
|
||||
CHECK(WaitForSingleObject(ev, 0) == WAIT_TIMEOUT, "pulse left signaled");
|
||||
CHECK(woke == 4, "pulse woke %d of 4", woke);
|
||||
CloseHandle(ev);
|
||||
ev = CreateEventA(NULL, FALSE, FALSE, NULL);
|
||||
PulseEvent(ev);
|
||||
CHECK(WaitForSingleObject(ev, 0) == WAIT_TIMEOUT, "auto pulse without waiter left signaled");
|
||||
th[0] = CreateThread(NULL, 0, close_waiter, ev, 0, NULL);
|
||||
th[1] = CreateThread(NULL, 0, close_waiter, ev, 0, NULL);
|
||||
Sleep(50);
|
||||
PulseEvent(ev);
|
||||
WaitForMultipleObjects(2, th, TRUE, INFINITE);
|
||||
woke = 0;
|
||||
for (i = 0; i < 2; i++) { GetExitCodeThread(th[i], &code); if (code == WAIT_OBJECT_0) woke++; CloseHandle(th[i]); }
|
||||
CHECK(woke == 1, "auto pulse woke %d of 2", woke);
|
||||
CHECK(WaitForSingleObject(ev, 0) == WAIT_TIMEOUT, "auto pulse left signaled");
|
||||
CloseHandle(ev);
|
||||
printf("pulse ok\n");
|
||||
}
|
||||
|
||||
static void test_semantics(void)
|
||||
{
|
||||
HANDLE ev = CreateEventA(NULL, TRUE, TRUE, NULL), sem = CreateSemaphoreA(NULL, 2, 3, NULL), h[2];
|
||||
NTSTATUS (WINAPI *pNtWaitForSingleObject)(HANDLE, BOOLEAN, const LARGE_INTEGER *);
|
||||
LARGE_INTEGER when;
|
||||
LONG prev = -1;
|
||||
DWORD r, start;
|
||||
int i;
|
||||
pNtWaitForSingleObject = (void *)GetProcAddress(GetModuleHandleA("ntdll.dll"), "NtWaitForSingleObject");
|
||||
apc_ran = 0;
|
||||
QueueUserAPC(apc_proc, GetCurrentThread(), 0);
|
||||
r = WaitForSingleObjectEx(ev, INFINITE, TRUE);
|
||||
CHECK(r == WAIT_OBJECT_0 && apc_ran == 0, "object before apc %lu ran %ld", r, apc_ran);
|
||||
r = SleepEx(0, TRUE);
|
||||
CHECK(r == WAIT_IO_COMPLETION && apc_ran == 1, "apc after object %lu ran %ld", r, apc_ran);
|
||||
r = SleepEx(0, TRUE);
|
||||
CHECK(r == 0, "sleepex zero %lu", r);
|
||||
ResetEvent(ev);
|
||||
GetSystemTimeAsFileTime((FILETIME *)&when);
|
||||
when.QuadPart += 2000000;
|
||||
start = GetTickCount();
|
||||
r = pNtWaitForSingleObject(ev, FALSE, &when);
|
||||
CHECK(r == STATUS_TIMEOUT, "absolute timeout status %lx", r);
|
||||
CHECK(GetTickCount() - start >= 150 && GetTickCount() - start < 1500, "absolute timeout took %lu", GetTickCount() - start);
|
||||
CHECK(!ReleaseSemaphore(sem, 2, &prev) && GetLastError() == ERROR_TOO_MANY_POSTS, "semaphore limit");
|
||||
CHECK(ReleaseSemaphore(sem, 1, &prev) && prev == 2, "semaphore prev %ld", prev);
|
||||
for (i = 0; i < 3; i++) CHECK(WaitForSingleObject(sem, 0) == WAIT_OBJECT_0, "semaphore take %d", i);
|
||||
CHECK(WaitForSingleObject(sem, 0) == WAIT_TIMEOUT, "semaphore empty");
|
||||
h[0] = sem; h[1] = ev;
|
||||
ReleaseSemaphore(sem, 1, NULL);
|
||||
CHECK(WaitForMultipleObjects(2, h, TRUE, 50) == WAIT_TIMEOUT, "wait all partial");
|
||||
CHECK(ReleaseSemaphore(sem, 0, &prev) && prev == 1, "wait all rollback lost token prev %ld", prev);
|
||||
SetEvent(ev);
|
||||
CHECK(WaitForMultipleObjects(2, h, TRUE, 50) == WAIT_OBJECT_0, "wait all ready");
|
||||
CHECK(ReleaseSemaphore(sem, 0, &prev) && prev == 0, "wait all consumed prev %ld", prev);
|
||||
CHECK(WaitForSingleObject(ev, 0) == WAIT_OBJECT_0, "manual stays set");
|
||||
CloseHandle(sem);
|
||||
CloseHandle(ev);
|
||||
printf("semantics ok\n");
|
||||
}
|
||||
|
||||
static HANDLE token_sem;
|
||||
static volatile LONG token_count;
|
||||
|
||||
static DWORD WINAPI token_worker(void *arg)
|
||||
{
|
||||
HANDLE h[2] = { token_sem, (HANDLE)arg };
|
||||
int i;
|
||||
for (i = 0; i < 20000; i++)
|
||||
{
|
||||
DWORD r = (i & 1) ? WaitForSingleObject(token_sem, INFINITE) : WaitForMultipleObjects(2, h, TRUE, INFINITE);
|
||||
if (r != WAIT_OBJECT_0) { CHECK(0, "token wait %lu", r); break; }
|
||||
if (InterlockedIncrement(&token_count) > 3) CHECK(0, "token overcommit");
|
||||
InterlockedDecrement(&token_count);
|
||||
if (!(i & 1)) SetEvent((HANDLE)arg);
|
||||
ReleaseSemaphore(token_sem, 1, NULL);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void test_semaphore_tokens(void)
|
||||
{
|
||||
HANDLE th[6], ev = CreateEventA(NULL, FALSE, TRUE, NULL);
|
||||
LONG prev = -1;
|
||||
int i;
|
||||
token_sem = CreateSemaphoreA(NULL, 3, 3, NULL);
|
||||
for (i = 0; i < 6; i++) th[i] = CreateThread(NULL, 0, token_worker, ev, 0, NULL);
|
||||
WaitForMultipleObjects(6, th, TRUE, INFINITE);
|
||||
for (i = 0; i < 6; i++) CloseHandle(th[i]);
|
||||
CHECK(ReleaseSemaphore(token_sem, 0, &prev) && prev == 3, "token final count %ld", prev);
|
||||
for (i = 0; i < 3; i++) CHECK(WaitForSingleObject(token_sem, 0) == WAIT_OBJECT_0, "token drain %d", i);
|
||||
CHECK(WaitForSingleObject(token_sem, 0) == WAIT_TIMEOUT, "token extra");
|
||||
CHECK(WaitForSingleObject(ev, 0) == WAIT_OBJECT_0, "token event lost");
|
||||
CloseHandle(token_sem);
|
||||
CloseHandle(ev);
|
||||
printf("semaphore_tokens ok\n");
|
||||
}
|
||||
|
||||
static volatile LONG churn_ready;
|
||||
|
||||
static DWORD WINAPI churn_mutex(void *arg)
|
||||
{
|
||||
HANDLE h[2] = { (HANDLE)arg, ev_manual };
|
||||
unsigned int i = 0;
|
||||
if (WaitForMultipleObjects(2, h, TRUE, INFINITE) <= WAIT_ABANDONED_0 + 1) ReleaseMutex(h[0]);
|
||||
InterlockedIncrement(&churn_ready);
|
||||
for (;;)
|
||||
{
|
||||
DWORD r = (i++ & 1) ? WaitForSingleObject(h[0], INFINITE) : WaitForMultipleObjects(2, h, TRUE, INFINITE);
|
||||
if (r == WAIT_OBJECT_0 || r == WAIT_ABANDONED || r == WAIT_ABANDONED_0) ReleaseMutex(h[0]);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
static DWORD WINAPI blocked_waiter(void *arg)
|
||||
{
|
||||
WaitForSingleObject((HANDLE)arg, 0);
|
||||
InterlockedIncrement(&churn_ready);
|
||||
return WaitForSingleObject((HANDLE)arg, INFINITE);
|
||||
}
|
||||
|
||||
static void test_terminate(void)
|
||||
{
|
||||
HANDLE th[4], m, ev;
|
||||
DWORD r, start;
|
||||
int round, i, stuck = 0;
|
||||
ev_manual = CreateEventA(NULL, TRUE, TRUE, NULL);
|
||||
for (round = 0; round < 150; round++)
|
||||
{
|
||||
m = CreateMutexA(NULL, FALSE, NULL);
|
||||
churn_ready = 0;
|
||||
for (i = 0; i < 4; i++) th[i] = CreateThread(NULL, 0, churn_mutex, m, 0, NULL);
|
||||
while (churn_ready < 4) Sleep(0);
|
||||
Sleep(round % 4);
|
||||
for (i = 0; i < 4; i++) TerminateThread(th[i], 7);
|
||||
WaitForMultipleObjects(4, th, TRUE, INFINITE);
|
||||
r = WaitForSingleObject(m, 3000);
|
||||
if (r == WAIT_TIMEOUT) stuck++;
|
||||
else ReleaseMutex(m);
|
||||
for (i = 0; i < 4; i++) CloseHandle(th[i]);
|
||||
CloseHandle(m);
|
||||
}
|
||||
CHECK(!stuck, "mutex stuck after terminate in %d rounds", stuck);
|
||||
ev = CreateEventA(NULL, TRUE, FALSE, NULL);
|
||||
churn_ready = 0;
|
||||
for (i = 0; i < 4; i++) th[i] = CreateThread(NULL, 0, blocked_waiter, ev, 0, NULL);
|
||||
while (churn_ready < 4) Sleep(0);
|
||||
Sleep(50);
|
||||
for (i = 0; i < 4; i++) TerminateThread(th[i], 7);
|
||||
WaitForMultipleObjects(4, th, TRUE, INFINITE);
|
||||
for (i = 0; i < 4; i++) CloseHandle(th[i]);
|
||||
start = GetTickCount();
|
||||
for (i = 0; i < 100; i++) PulseEvent(ev);
|
||||
CHECK(GetTickCount() - start < 400, "pulse after killed waiters took %lu ms", GetTickCount() - start);
|
||||
CHECK(WaitForSingleObject(ev, 0) == WAIT_TIMEOUT, "pulse left event set");
|
||||
CloseHandle(ev);
|
||||
CloseHandle(ev_manual);
|
||||
printf("terminate ok\n");
|
||||
}
|
||||
|
||||
static void test_cross_process(const char *self)
|
||||
{
|
||||
HANDLE ev = CreateEventA(NULL, FALSE, FALSE, "Local\\esstress_ev");
|
||||
HANDLE done = CreateEventA(NULL, TRUE, FALSE, "Local\\esstress_done");
|
||||
HANDLE sm = CreateSemaphoreA(NULL, 0, 100000, "Local\\esstress_sem");
|
||||
PROCESS_INFORMATION pi;
|
||||
STARTUPINFOA si = { sizeof(si) };
|
||||
char cmd[MAX_PATH + 16];
|
||||
DWORD r, code;
|
||||
int i;
|
||||
sprintf(cmd, "\"%s\" child", self);
|
||||
CHECK(CreateProcessA(NULL, cmd, NULL, NULL, FALSE, 0, NULL, NULL, &si, &pi), "createprocess %lu", GetLastError());
|
||||
for (i = 0; i < 5000; i++)
|
||||
{
|
||||
SetEvent(ev);
|
||||
r = WaitForSingleObject(sm, 5000);
|
||||
if (r != WAIT_OBJECT_0) { CHECK(0, "xproc wait %lu at %d", r, i); break; }
|
||||
}
|
||||
SetEvent(done);
|
||||
r = WaitForSingleObject(pi.hProcess, 10000);
|
||||
CHECK(r == WAIT_OBJECT_0, "child exit wait %lu", r);
|
||||
GetExitCodeProcess(pi.hProcess, &code);
|
||||
CHECK(code == 0, "child code %lu", code);
|
||||
CloseHandle(pi.hProcess); CloseHandle(pi.hThread);
|
||||
CloseHandle(ev); CloseHandle(done); CloseHandle(sm);
|
||||
printf("cross_process ok\n");
|
||||
}
|
||||
|
||||
static int child(void)
|
||||
{
|
||||
HANDLE ev = OpenEventA(SYNCHRONIZE | EVENT_MODIFY_STATE, FALSE, "Local\\esstress_ev");
|
||||
HANDLE done = OpenEventA(SYNCHRONIZE, FALSE, "Local\\esstress_done");
|
||||
HANDLE sm = OpenSemaphoreA(SEMAPHORE_MODIFY_STATE | SYNCHRONIZE, FALSE, "Local\\esstress_sem");
|
||||
HANDLE objs[2];
|
||||
objs[0] = done; objs[1] = ev;
|
||||
if (!ev || !done || !sm) return 1;
|
||||
for (;;)
|
||||
{
|
||||
DWORD r = WaitForMultipleObjects(2, objs, FALSE, 10000);
|
||||
if (r == WAIT_OBJECT_0) return 0;
|
||||
if (r != WAIT_OBJECT_0 + 1) return 2;
|
||||
ReleaseSemaphore(sm, 1, NULL);
|
||||
}
|
||||
}
|
||||
|
||||
static void test_kill_holder(const char *self)
|
||||
{
|
||||
HANDLE m = CreateMutexA(NULL, FALSE, "Local\\esstress_mutex");
|
||||
PROCESS_INFORMATION pi;
|
||||
STARTUPINFOA si = { sizeof(si) };
|
||||
char cmd[MAX_PATH + 16];
|
||||
DWORD r;
|
||||
sprintf(cmd, "\"%s\" holder", self);
|
||||
CreateProcessA(NULL, cmd, NULL, NULL, FALSE, 0, NULL, NULL, &si, &pi);
|
||||
Sleep(500);
|
||||
TerminateProcess(pi.hProcess, 7);
|
||||
WaitForSingleObject(pi.hProcess, INFINITE);
|
||||
r = WaitForSingleObject(m, 3000);
|
||||
CHECK(r == WAIT_ABANDONED, "killed holder %lu", r);
|
||||
ReleaseMutex(m);
|
||||
CloseHandle(pi.hProcess); CloseHandle(pi.hThread); CloseHandle(m);
|
||||
printf("kill_holder ok\n");
|
||||
}
|
||||
|
||||
static int holder(void)
|
||||
{
|
||||
HANDLE m = OpenMutexA(SYNCHRONIZE, FALSE, "Local\\esstress_mutex");
|
||||
WaitForSingleObject(m, INFINITE);
|
||||
Sleep(INFINITE);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void test_many_objects(void)
|
||||
{
|
||||
static HANDLE h[20000];
|
||||
int i, n = 0;
|
||||
for (i = 0; i < 20000; i++)
|
||||
{
|
||||
if (!(h[i] = CreateEventA(NULL, i & 1, i & 2, NULL))) break;
|
||||
n++;
|
||||
}
|
||||
CHECK(n == 20000, "created %d", n);
|
||||
for (i = 0; i < n; i++) CHECK(WaitForSingleObject(h[i], 0) == ((i & 2) ? WAIT_OBJECT_0 : WAIT_TIMEOUT), "obj %d", i);
|
||||
for (i = 0; i < n; i++) CloseHandle(h[i]);
|
||||
for (i = 0; i < 100000; i++)
|
||||
{
|
||||
HANDLE e = CreateEventA(NULL, FALSE, TRUE, NULL);
|
||||
if (WaitForSingleObject(e, 0) != WAIT_OBJECT_0) { CHECK(0, "churn %d", i); CloseHandle(e); break; }
|
||||
CloseHandle(e);
|
||||
}
|
||||
printf("many_objects ok\n");
|
||||
}
|
||||
|
||||
static void test_timers_and_threads(void)
|
||||
{
|
||||
HANDLE t = CreateWaitableTimerA(NULL, FALSE, NULL);
|
||||
LARGE_INTEGER due;
|
||||
DWORD start = GetTickCount(), r;
|
||||
int i;
|
||||
due.QuadPart = -10 * 1000 * 20;
|
||||
SetWaitableTimer(t, &due, 10, NULL, NULL, FALSE);
|
||||
for (i = 0; i < 20; i++)
|
||||
{
|
||||
r = WaitForSingleObject(t, 1000);
|
||||
CHECK(r == WAIT_OBJECT_0, "timer %d %lu", i, r);
|
||||
}
|
||||
CHECK(GetTickCount() - start < 2000, "timer slow %lu", GetTickCount() - start);
|
||||
CancelWaitableTimer(t);
|
||||
CloseHandle(t);
|
||||
r = WaitForSingleObject(GetCurrentProcess(), 10);
|
||||
CHECK(r == WAIT_TIMEOUT, "process self %lu", r);
|
||||
printf("timers ok\n");
|
||||
}
|
||||
|
||||
int main(int argc, char **argv)
|
||||
{
|
||||
if (argc > 1 && !strcmp(argv[1], "child")) return child();
|
||||
if (argc > 1 && !strcmp(argv[1], "holder")) return holder();
|
||||
test_mutex_contention();
|
||||
test_semaphore();
|
||||
test_auto_event();
|
||||
test_manual_event();
|
||||
test_wait_all();
|
||||
test_abandoned();
|
||||
test_apc();
|
||||
test_close_while_waiting();
|
||||
test_pulse();
|
||||
test_semantics();
|
||||
test_semaphore_tokens();
|
||||
if (argc > 1 && !strcmp(argv[1], "terminate")) test_terminate();
|
||||
test_cross_process(argv[0]);
|
||||
test_kill_holder(argv[0]);
|
||||
test_many_objects();
|
||||
test_timers_and_threads();
|
||||
printf("esstress: %d failures\n", failures);
|
||||
return failures ? 1 : 0;
|
||||
}
|
||||
Executable
+48
@@ -0,0 +1,48 @@
|
||||
#!/bin/sh
|
||||
set -eu
|
||||
out=${1:?usage: build-x86-preloads.sh <linuxfs asset directory>}
|
||||
for arch in x86_64 i386; do
|
||||
case $arch in
|
||||
x86_64) bits=-m64 ;;
|
||||
i386) bits=-m32 ;;
|
||||
esac
|
||||
mkdir -p "$out/$arch"
|
||||
gcc $bits -shared -fPIC -O2 -Wall -pthread \
|
||||
-o "$out/$arch/libblsession.so" tools/linuxfs/preload/*.c -ldl
|
||||
g++ $bits -shared -fPIC -O2 -Wall -Wno-attributes -Wno-nonnull-compare \
|
||||
-pthread -std=c++17 -static-libstdc++ -static-libgcc -Wl,--exclude-libs,ALL \
|
||||
-o "$out/$arch/libfakeinput.so" app/src/main/cpp/fakeinput_steam.cpp -ldl
|
||||
strip --strip-unneeded "$out/$arch/libblsession.so" "$out/$arch/libfakeinput.so"
|
||||
for lib in "$out/$arch/libblsession.so" "$out/$arch/libfakeinput.so"; do
|
||||
newest=$(objdump -T "$lib" | grep -o 'GLIBC_2\.[0-9]*' | sort -u -t. -k2,2n | tail -1)
|
||||
minor=${newest#GLIBC_2.}
|
||||
if [ "$minor" -gt 31 ]; then
|
||||
echo "$lib needs $newest; Steam Linux Runtime 3.0 has glibc 2.31" >&2
|
||||
exit 1
|
||||
fi
|
||||
if objdump -p "$lib" | grep -q 'NEEDED.*lib\(stdc++\|gcc_s\)'; then
|
||||
echo "$lib links the C++ runtime dynamically" >&2
|
||||
exit 1
|
||||
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 \
|
||||
-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
|
||||
echo "$lib must not need any library" >&2
|
||||
exit 1
|
||||
fi
|
||||
done
|
||||
stub=$(mktemp -d)
|
||||
gcc -m64 -shared -nostdlib -Wl,-soname,/usr/lib/x86_64-linux-gnu/libvulkan.so.1 -o "$stub/libvulkan.so.1" -x c /dev/null
|
||||
gcc -m64 -shared -nostdlib -Wl,-z,nodelete -Wl,--no-as-needed \
|
||||
-o "$out/x86_64/libvulkan-thunk.so" -x c /dev/null -x none "$stub/libvulkan.so.1"
|
||||
rm -rf "$stub"
|
||||
if ! objdump -p "$out/x86_64/libvulkan-thunk.so" | grep -q 'NEEDED *\/usr/lib/x86_64-linux-gnu/libvulkan\.so\.1$' \
|
||||
|| ! objdump -p "$out/x86_64/libvulkan-thunk.so" | grep -q 'FLAGS_1 *0x0*8$'; then
|
||||
echo "$out/x86_64/libvulkan-thunk.so must be nodelete and need only the Vulkan thunk" >&2
|
||||
exit 1
|
||||
fi
|
||||
@@ -39,7 +39,7 @@ run lxqt-panel lxqt-panel
|
||||
# The desktop was asked for with Steam in it (the front end's "Steam Desktop UI", Big Picture's
|
||||
# "Switch to Desktop"): the client's desktop UI, as the menu's Steam entry opens it. A running
|
||||
# client just gets the request; on a software desktop it goes back to the app as a Steam session.
|
||||
[ "${BL_DESKTOP_STEAM:-0}" = 1 ] && run steam /usr/local/bin/bannerlator-steam-launch desktop
|
||||
[ "${BL_DESKTOP_STEAM:-0}" = 1 ] && run steam /usr/local/bin/droiddeck-steam-launch desktop
|
||||
# Remote runs, for driving the desktop from a debugger: with ~/.droiddeck-remote-run present (only
|
||||
# the app or root can create it), each script dropped into ~/.cache/droiddeck/run/ is run once,
|
||||
# inside the session with its environment, its output tagged into the desktop log.
|
||||
|
||||
@@ -1,7 +1,7 @@
|
||||
#!/bin/bash
|
||||
# The desktop session: labwc nested as a client of the app's compositor, with LXQt's panel and
|
||||
# file manager started from its autostart, and Xwayland for the X11 programs (the Steam client,
|
||||
# most emulators). Run by bannerlator-session in place of gamescope for mode "lxqt".
|
||||
# most emulators). Run by droiddeck-session in place of gamescope for mode "lxqt".
|
||||
# Staged by the app over the desktop package's copy on every launch, so a fix here reaches an
|
||||
# installed desktop without re-downloading the package.
|
||||
set -u
|
||||
@@ -114,16 +114,16 @@ if [ ! -f /var/cache/fontconfig/.droiddeck-built ] && command -v fc-cache >/dev/
|
||||
echo "== fontconfig: cache rebuilt, default sans is $(fc-match sans-serif 2>/dev/null)"
|
||||
fi
|
||||
# The menu's "Steam" / "Steam Big Picture" entries and one entry per installed game: all of them
|
||||
# hand off to the app (bannerlator-steam-launch), since the client cannot draw on this desktop.
|
||||
# hand off to the app (droiddeck-steam-launch), since the client cannot draw on this desktop.
|
||||
export BL_DESKTOP=1
|
||||
ln -sf /usr/local/bin/bannerlator-steam-launch /usr/local/bin/steamdeck-steam 2>/dev/null
|
||||
ln -sf /usr/local/bin/bannerlator-steam-shim /usr/local/bin/steam 2>/dev/null
|
||||
python3 /usr/local/bin/bannerlator-desktop-games 2>&1 | sed 's/^/[games] /'
|
||||
ln -sf /usr/local/bin/droiddeck-steam-launch /usr/local/bin/steamdeck-steam 2>/dev/null
|
||||
ln -sf /usr/local/bin/droiddeck-steam-shim /usr/local/bin/steam 2>/dev/null
|
||||
python3 /usr/local/bin/droiddeck-desktop-games 2>&1 | sed 's/^/[games] /'
|
||||
# Player 1 on the controller in every emulator that has no profile of its own yet - now, and again
|
||||
# every half minute: an emulator started for the first time writes its own config, which is then
|
||||
# given the controller for its next start without waiting for the next desktop.
|
||||
python3 /usr/local/bin/bannerlator-pad-defaults 2>&1 | sed 's/^/[pads] /'
|
||||
( while sleep 30; do python3 /usr/local/bin/bannerlator-pad-defaults 2>&1 | sed 's/^/[pads] /'; done ) &
|
||||
python3 /usr/local/bin/droiddeck-pad-defaults 2>&1 | sed 's/^/[pads] /'
|
||||
( while sleep 30; do python3 /usr/local/bin/droiddeck-pad-defaults 2>&1 | sed 's/^/[pads] /'; done ) &
|
||||
# Games and emulators from the menu run through droiddeck-gpu (their own gamescope on the app's
|
||||
# compositor) while the desktop is on pixman, where they could not draw with the GPU.
|
||||
# BL_DESKTOP_GPU=on/off overrides; each entry keeps "Run in a desktop window" either way.
|
||||
|
||||
@@ -18,7 +18,7 @@ LOCAL_DIR = "/usr/local/share/applications"
|
||||
FLATPAK_DIR = os.path.join(HOME, ".local/share/flatpak/exports/share/applications")
|
||||
USER_DIR = os.path.join(HOME, ".local/share/applications")
|
||||
MARK = "X-DroidDeck-GPU=1"
|
||||
# The client and its games already hand themselves to the app (bannerlator-steam-launch).
|
||||
# The client and its games already hand themselves to the app (droiddeck-steam-launch).
|
||||
SKIP = re.compile(r"^(steam|droiddeck-game-|droiddeck-steam|steamdeck-)", re.I)
|
||||
|
||||
|
||||
@@ -45,7 +45,7 @@ def gpu_exec(exec_line):
|
||||
"""The Exec that runs a program on the GPU; a Flatpak app goes through its launcher, which
|
||||
keeps it on gamescope's X server instead of the desktop's Wayland socket."""
|
||||
if exec_line.startswith("/usr/bin/flatpak run ") or exec_line.startswith("flatpak run "):
|
||||
exec_line = "/usr/local/bin/bannerlator-flatpak-run " + exec_line.split(" run ", 1)[1]
|
||||
exec_line = "/usr/local/bin/droiddeck-flatpak-run " + exec_line.split(" run ", 1)[1]
|
||||
return "droiddeck-gpu " + exec_line
|
||||
|
||||
|
||||
|
||||
@@ -20,7 +20,7 @@
|
||||
</keyboard>
|
||||
<mouse><doubleClickTime>500</doubleClickTime></mouse>
|
||||
<!-- Programs opened on the desktop at a size that suits it. melonDS remembers a 1x window for the
|
||||
front end's full-screen toggle (bannerlator-pad-defaults), too small for a desktop: here it
|
||||
front end's full-screen toggle (droiddeck-pad-defaults), too small for a desktop: here it
|
||||
opens at 800x600, centred (AutoPlace alone kept the top-left corner). Only the desktop reads this file, so the front end is unaffected. -->
|
||||
<windowRules>
|
||||
<windowRule title="melonDS*">
|
||||
|
||||
@@ -0,0 +1,144 @@
|
||||
#if !defined(__x86_64__)
|
||||
#error faultreport is built for x86_64 guests only
|
||||
#endif
|
||||
|
||||
#define SYS_read 0
|
||||
#define SYS_write 1
|
||||
#define SYS_close 3
|
||||
#define SYS_rt_sigaction 13
|
||||
#define SYS_getpid 39
|
||||
#define SYS_gettid 186
|
||||
#define SYS_tgkill 234
|
||||
#define SYS_openat 257
|
||||
#define AT_FDCWD (-100)
|
||||
#define SIGILL 4
|
||||
#define SA_SIGINFO 0x4UL
|
||||
#define SA_RESTORER 0x04000000UL
|
||||
#define SA_NODEFER 0x40000000UL
|
||||
#define SA_RESETHAND 0x80000000UL
|
||||
|
||||
struct kernel_sigaction {
|
||||
void (*handler)(int, void *, void *);
|
||||
unsigned long flags;
|
||||
void (*restorer)(void);
|
||||
unsigned long mask;
|
||||
};
|
||||
|
||||
static long sys(long n, long a, long b, long c, long d)
|
||||
{
|
||||
long r;
|
||||
register long r10 __asm__("r10") = d;
|
||||
__asm__ volatile("syscall" : "=a"(r) : "a"(n), "D"(a), "S"(b), "d"(c), "r"(r10) : "rcx", "r11", "memory");
|
||||
return r;
|
||||
}
|
||||
|
||||
static char out[1024];
|
||||
static unsigned long used;
|
||||
static char maps[65536];
|
||||
|
||||
static void put(const char *s)
|
||||
{
|
||||
while (*s && used < sizeof(out) - 1)
|
||||
out[used++] = *s++;
|
||||
}
|
||||
|
||||
static void put_hex(unsigned long v, int digits)
|
||||
{
|
||||
char buf[17];
|
||||
for (int i = digits - 1; i >= 0; i--) {
|
||||
buf[i] = "0123456789abcdef"[v & 15];
|
||||
v >>= 4;
|
||||
}
|
||||
buf[digits] = 0;
|
||||
put(buf);
|
||||
}
|
||||
|
||||
static unsigned long parse_hex(const char **p)
|
||||
{
|
||||
unsigned long v = 0;
|
||||
for (;;) {
|
||||
char c = **p;
|
||||
if (c >= '0' && c <= '9') v = v * 16 + (c - '0');
|
||||
else if (c >= 'a' && c <= 'f') v = v * 16 + (c - 'a' + 10);
|
||||
else return v;
|
||||
(*p)++;
|
||||
}
|
||||
}
|
||||
|
||||
static int find_mapping(unsigned long addr, const char **line, unsigned long *length, unsigned long *start, int *readable)
|
||||
{
|
||||
long fd = sys(SYS_openat, AT_FDCWD, (long)"/proc/self/maps", 0, 0);
|
||||
if (fd < 0) return 0;
|
||||
unsigned long have = 0;
|
||||
long n;
|
||||
while (have < sizeof(maps) - 1 && (n = sys(SYS_read, fd, (long)(maps + have), sizeof(maps) - 1 - have, 0)) > 0)
|
||||
have += n;
|
||||
sys(SYS_close, fd, 0, 0, 0);
|
||||
maps[have] = 0;
|
||||
const char *p = maps;
|
||||
while (*p) {
|
||||
const char *begin = p;
|
||||
unsigned long lo = parse_hex(&p);
|
||||
if (*p == '-') p++;
|
||||
unsigned long hi = parse_hex(&p);
|
||||
while (*p == ' ') p++;
|
||||
int r = *p == 'r';
|
||||
const char *end = begin;
|
||||
while (*end && *end != '\n') end++;
|
||||
if (addr >= lo && addr < hi) {
|
||||
*line = begin;
|
||||
*length = end - begin;
|
||||
*start = lo;
|
||||
*readable = r && addr + 16 <= hi;
|
||||
return 1;
|
||||
}
|
||||
p = *end ? end + 1 : end;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void report(int sig, void *info, void *context)
|
||||
{
|
||||
(void)context;
|
||||
unsigned long addr = *(unsigned long *)((char *)info + 16);
|
||||
int code = *(int *)((char *)info + 8);
|
||||
used = 0;
|
||||
put("droiddeck-fex: SIGILL at 0x");
|
||||
put_hex(addr, 12);
|
||||
put(" (si_code ");
|
||||
put_hex((unsigned long)code, 2);
|
||||
put(")");
|
||||
const char *line;
|
||||
unsigned long length, start;
|
||||
int readable;
|
||||
if (find_mapping(addr, &line, &length, &start, &readable)) {
|
||||
put(", offset 0x");
|
||||
put_hex(addr - start, 8);
|
||||
if (readable) {
|
||||
put(", bytes");
|
||||
for (int i = 0; i < 16; i++) {
|
||||
put(" ");
|
||||
put_hex(((unsigned char *)addr)[i], 2);
|
||||
}
|
||||
}
|
||||
put("\n in ");
|
||||
for (unsigned long i = 0; i < length && used < sizeof(out) - 2; i++)
|
||||
out[used++] = line[i];
|
||||
} else {
|
||||
put(", outside any mapping");
|
||||
}
|
||||
put("\n");
|
||||
sys(SYS_write, 2, (long)out, used, 0);
|
||||
struct kernel_sigaction fallback = {0, 0, 0, 0};
|
||||
sys(SYS_rt_sigaction, sig, (long)&fallback, 0, sizeof(fallback.mask));
|
||||
sys(SYS_tgkill, sys(SYS_getpid, 0, 0, 0, 0), sys(SYS_gettid, 0, 0, 0, 0), sig, 0);
|
||||
}
|
||||
|
||||
void faultreport_restore(void);
|
||||
__asm__(".text\n.type faultreport_restore,@function\nfaultreport_restore:\nmov $15, %eax\nsyscall\nhlt\n");
|
||||
|
||||
__attribute__((constructor)) static void install(void)
|
||||
{
|
||||
struct kernel_sigaction action = {report, SA_SIGINFO | SA_NODEFER | SA_RESETHAND | SA_RESTORER, faultreport_restore, 0};
|
||||
sys(SYS_rt_sigaction, SIGILL, (long)&action, 0, sizeof(action.mask));
|
||||
}
|
||||
@@ -0,0 +1,40 @@
|
||||
#if !defined(__x86_64__)
|
||||
#error thunkaudit is built for x86_64 guests only
|
||||
#endif
|
||||
|
||||
#define LA_SER_ORIG 0x01
|
||||
|
||||
static const char vulkan_thunk[] = "/usr/lib/x86_64-linux-gnu/libvulkan.so.1";
|
||||
static const char vulkan_pin[] = "/usr/lib/x86_64-linux-gnu/droiddeck/libvulkan-thunk.so";
|
||||
|
||||
static int same(const char *a, const char *b)
|
||||
{
|
||||
while (*a && *a == *b) {
|
||||
a++;
|
||||
b++;
|
||||
}
|
||||
return *a == *b;
|
||||
}
|
||||
|
||||
static const char *base_name(const char *path)
|
||||
{
|
||||
const char *name = path;
|
||||
for (; *path; path++)
|
||||
if (*path == '/')
|
||||
name = path + 1;
|
||||
return name;
|
||||
}
|
||||
|
||||
__attribute__((visibility("default"))) unsigned int la_version(unsigned int version)
|
||||
{
|
||||
return version;
|
||||
}
|
||||
|
||||
__attribute__((visibility("default"))) char *la_objsearch(const char *name, unsigned long *cookie, unsigned int flag)
|
||||
{
|
||||
const char *file = base_name(name);
|
||||
(void)cookie;
|
||||
if (flag == LA_SER_ORIG && !same(name, vulkan_thunk) && (same(file, "libvulkan.so.1") || same(file, "libvulkan.so")))
|
||||
return (char *)vulkan_pin;
|
||||
return (char *)name;
|
||||
}
|
||||
@@ -0,0 +1,21 @@
|
||||
MIT License
|
||||
|
||||
Copyright (c) 2026 VHSgunzo
|
||||
|
||||
Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
of this software and associated documentation files (the "Software"), to deal
|
||||
in the Software without restriction, including without limitation the rights
|
||||
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
copies of the Software, and to permit persons to whom the Software is
|
||||
furnished to do so, subject to the following conditions:
|
||||
|
||||
The above copyright notice and this permission notice shall be included in all
|
||||
copies or substantial portions of the Software.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||
SOFTWARE.
|
||||
@@ -3,7 +3,7 @@
|
||||
# session: "plasma", "plasma-wayland-persistent", ...) and waits for Game Mode to end; with nothing
|
||||
# here it sat on "Switching to Desktop..." for ever. Here the desktop is DroidDeck's own: the app is
|
||||
# asked for a desktop session with Steam's desktop client open in it (the request file
|
||||
# bannerlator-steam-launch uses; the app ends this session and starts that one). Anything else -
|
||||
# droiddeck-steam-launch uses; the app ends this session and starts that one). Anything else -
|
||||
# "gamescope", the session Game Mode already is - has nothing to do.
|
||||
echo "steamos-session-select: $*" >&2
|
||||
case "${1:-}" in
|
||||
|
||||
@@ -1,69 +0,0 @@
|
||||
#!/bin/bash
|
||||
# An AppImage imported from the front end (AppImageManager), extracted once at import into
|
||||
# /opt/appimages/user/<id>/app
|
||||
# and started from there: proot has no FUSE to mount the image, and extracting it at every
|
||||
# start (APPIMAGE_EXTRACT_AND_RUN) would cost the whole image in /tmp each time.
|
||||
# bannerlator-appimage-run /opt/appimages/user/<id> [args...]
|
||||
set -u
|
||||
dir=${1:?usage: bannerlator-appimage-run <imported AppImage directory> [args...]}
|
||||
shift
|
||||
export APPDIR=$dir/app
|
||||
# APPIMAGE is left unset on purpose: with it an app believes it runs from an image file and offers
|
||||
# to add itself to the menu (DuckStation) or update the file in place - DroidDeck already does the
|
||||
# one, and there is no image file for the other.
|
||||
unset APPIMAGE
|
||||
export ARGV0=$(cat "$dir/name" 2>/dev/null || basename "$dir")
|
||||
if [ ! -x "$APPDIR/AppRun" ]; then
|
||||
echo "bannerlator-appimage-run: $APPDIR/AppRun is missing; import the AppImage again" >&2
|
||||
exit 127
|
||||
fi
|
||||
# Browsers sandbox their own children with namespaces and a setuid helper, neither of which proot
|
||||
# can give them (the Flatpak sandboxes get the same; see BwrapSpawner): Firefox and its forks (Zen,
|
||||
# LibreWolf) by these switches, Electron and Chromium builds by --no-sandbox. Chromium on Wayland
|
||||
# also asks the render node for a DRM version KGSL cannot give, so with an X server up it stays on
|
||||
# X11, which it picks from the session type.
|
||||
export MOZ_DISABLE_CONTENT_SANDBOX=1 MOZ_DISABLE_GMP_SANDBOX=1 MOZ_DISABLE_RDD_SANDBOX=1
|
||||
export MOZ_DISABLE_SOCKET_PROCESS_SANDBOX=1 MOZ_DISABLE_UTILITY_SANDBOX=1
|
||||
# sharun images start the app through their own ld.so, patched not to read /etc/ld.so.preload, and
|
||||
# drop LD_PRELOAD unless allowed: without this the app never gets the session's pads.
|
||||
if [ -s /etc/ld.so.preload ]; then
|
||||
preload=$(tr -s '\n' ':' < /etc/ld.so.preload)
|
||||
export LD_PRELOAD="${preload%:}${LD_PRELOAD:+:$LD_PRELOAD}" SHARUN_ALLOW_LD_PRELOAD=1
|
||||
fi
|
||||
flags=()
|
||||
if [ -e "$APPDIR/chrome-sandbox" ] || compgen -G "$APPDIR/*/chrome-sandbox" >/dev/null; then
|
||||
flags+=(--no-sandbox)
|
||||
if [ -n "${DISPLAY:-}" ]; then
|
||||
export XDG_SESSION_TYPE=x11
|
||||
unset WAYLAND_DISPLAY
|
||||
flags+=(--ozone-platform=x11)
|
||||
fi
|
||||
fi
|
||||
echo "== appimage $ARGV0 ($APPDIR) ${flags[*]}"
|
||||
cd "$APPDIR" || exit 1
|
||||
# Apps expect a session bus; Electron's main process traps (SIGTRAP) on an address it cannot
|
||||
# parse. A run mode has none, so one is started for the app, as for Flatpak apps.
|
||||
case ${DBUS_SESSION_BUS_ADDRESS:-} in
|
||||
unix:*) "$APPDIR/AppRun" "${flags[@]}" "$@" ;;
|
||||
*) unset DBUS_SESSION_BUS_ADDRESS
|
||||
if command -v dbus-run-session >/dev/null 2>&1; then
|
||||
dbus-run-session -- "$APPDIR/AppRun" "${flags[@]}" "$@"
|
||||
else
|
||||
"$APPDIR/AppRun" "${flags[@]}" "$@"
|
||||
fi ;;
|
||||
esac
|
||||
rc=$?
|
||||
# The program a session was started for may hand over to another process and exit: Electron apps
|
||||
# relaunch themselves (Obsidian on its first start), launchers fork their real program. The
|
||||
# session ends with this script, and takes the rest with it - so it waits while anything running
|
||||
# from the image is still up.
|
||||
image_running() {
|
||||
local p exe
|
||||
for p in /proc/[0-9]*; do
|
||||
exe=$(readlink "$p/exe" 2>/dev/null) || continue
|
||||
case $exe in "$APPDIR"/*) return 0 ;; esac
|
||||
done
|
||||
return 1
|
||||
}
|
||||
while image_running; do sleep 2; done
|
||||
exit $rc
|
||||
@@ -1,37 +0,0 @@
|
||||
#!/bin/bash
|
||||
# A script added on the Desktop page (UserApps), run from its own folder:
|
||||
# bannerlator-script-run /opt/droiddeck-apps/<id> [args...]
|
||||
set -u
|
||||
dir=${1:?usage: bannerlator-script-run <added app directory> [args...]}
|
||||
shift
|
||||
entry=$(cat "$dir/entry" 2>/dev/null) || { echo "bannerlator-script-run: $dir has no entry" >&2; exit 127; }
|
||||
cd -P "$dir/files" 2>/dev/null || { echo "bannerlator-script-run: $dir/files is missing; add the script again" >&2; exit 127; }
|
||||
folder=$PWD
|
||||
# Shared storage is noexec, so the script is handed to its interpreter rather than executed.
|
||||
first=
|
||||
IFS= read -r first < "$entry"
|
||||
first=${first%$'\r'}
|
||||
interp=(/bin/bash)
|
||||
case $first in '#!'*) read -r -a interp <<< "${first#'#!'}" ;; esac
|
||||
echo "== script $entry in $folder (${interp[*]})"
|
||||
case ${DBUS_SESSION_BUS_ADDRESS:-} in
|
||||
unix:*) "${interp[@]}" "./$entry" "$@" ;;
|
||||
*) unset DBUS_SESSION_BUS_ADDRESS
|
||||
if command -v dbus-run-session >/dev/null 2>&1; then
|
||||
dbus-run-session -- "${interp[@]}" "./$entry" "$@"
|
||||
else
|
||||
"${interp[@]}" "./$entry" "$@"
|
||||
fi ;;
|
||||
esac
|
||||
rc=$?
|
||||
# A launcher script often starts the game and returns; the session lasts while it runs.
|
||||
running() {
|
||||
local p exe
|
||||
for p in /proc/[0-9]*; do
|
||||
exe=$(readlink "$p/exe" 2>/dev/null) || continue
|
||||
case $exe in "$folder"/*) return 0 ;; esac
|
||||
done
|
||||
return 1
|
||||
}
|
||||
while running; do sleep 2; done
|
||||
exit $rc
|
||||
@@ -1,641 +0,0 @@
|
||||
#!/usr/bin/python3
|
||||
# Makes the ARM64 Proton the client already downloaded usable here, and sets it as the default tool
|
||||
# for Windows titles (CompatToolMapping "0" in config.vdf) when the user has not chosen one. Run
|
||||
# before the client starts; it rewrites config.vdf on exit.
|
||||
#
|
||||
# bannerlator-steam-compat <steam root>
|
||||
#
|
||||
# Valve ships a native aarch64 Proton (arm64ec Wine with FEX as the x86 layer) as an ordinary depot,
|
||||
# which is exactly what this runtime wants. Its toolmanifest declares require_tool_appid 4185400 -
|
||||
# Steam Linux Runtime 4 for arm64 - so Steam stacks pressure-vessel underneath it, and
|
||||
# pressure-vessel needs unprivileged user namespaces, which an Android app does not get. Steam then
|
||||
# drops the launch on the floor: no window, no log, straight back to the library.
|
||||
#
|
||||
# So the depot is re-registered here as a compatibility tool of our own: every entry symlinked so
|
||||
# nothing is copied and Steam still updates the real depot, but with a toolmanifest that leaves out
|
||||
# require_tool_appid. Proton takes its base directory from dirname(sys.argv[0]) without resolving
|
||||
# it, so it reads files/ through those symlinks and runs directly on this rootfs.
|
||||
import os
|
||||
import re
|
||||
import shutil
|
||||
import sys
|
||||
|
||||
TOOL = "bannerlator-proton-arm64"
|
||||
# Valve's own ARM64 Proton, by the name the client registers it under. Used only to bootstrap a
|
||||
# fresh install: naming it is what makes the client offer it and fetch the depot.
|
||||
SEED_TOOL = "proton-experimental-arm64"
|
||||
# The ARM64 Proton depot the client downloads for itself, as a compatibility-tool appid.
|
||||
# The session asks the client to install it on the command line the first time (steam://install),
|
||||
# so a new client has it before a Windows title is first launched. It is deliberately NOT named as
|
||||
# this tool's dependency: a dependency is composed with its own dependencies, and this depot
|
||||
# requires 4185400, the arm64 Steam Linux Runtime, whose container needs user namespaces Android
|
||||
# does not give - the launch would be wrapped in it and die before this tool ever ran.
|
||||
PROTON_ARM64_APPID = "4427310"
|
||||
LAUNCHER = "bannerlator-proton"
|
||||
# The extra Steam library the app mounts the installed games into (see bannerlator-steam-library).
|
||||
# installed_apps() scans it too; it lives only in the sibling script, so define it here as well.
|
||||
LIBRARY = "/mnt/bannerlator" # the card library is LIBRARY + "-sd"; internal storage is steam_root itself
|
||||
# The client lists its own "Proton Experimental (ARM64)" and "Proton 11.0 (ARM64)" in the same
|
||||
# Compatibility dropdown, and those are the two that cannot start a game here. Ours has to be
|
||||
# unmistakable at a glance, or a user picks a neighbour and gets a launch that fails silently.
|
||||
# Newest first: whichever the client has downloaded is used.
|
||||
SOURCES = ("Proton Experimental (ARM64)", "Proton 11.0 (ARM64)")
|
||||
# Written by us; everything else in the depot is symlinked through.
|
||||
OWN_FILES = ("toolmanifest.vdf", "compatibilitytool.vdf", "bannerlator-proton")
|
||||
# The client assigns a Proton to a Windows title by itself, as a per-app CompatToolMapping entry at
|
||||
# priority 250 - which outranks the "0" default, so setting that default alone changes nothing. Every
|
||||
# Proton it can pick is one this runtime cannot start: the ARM64 ones want pressure-vessel (see
|
||||
# above) and the x86_64 ones want pressure-vessel and FEX on top. Ours is the only one that runs
|
||||
# here, so every Proton mapping is repointed at it. Tools that are not Proton are left alone.
|
||||
COMPAT_TOOL_VDF = """"compatibilitytools"
|
||||
{
|
||||
"compat_tools"
|
||||
{
|
||||
"%s"
|
||||
{
|
||||
"install_path" "."
|
||||
"display_name" "Bannerlator Proton (ARM64)"
|
||||
"from_oslist" "windows"
|
||||
"to_oslist" "linux"
|
||||
}
|
||||
}
|
||||
}
|
||||
"""
|
||||
TOOL_MANIFEST_VDF = """"manifest"
|
||||
{
|
||||
"version" "2"
|
||||
"commandline" "/%s %%verb%%"
|
||||
"use_sessions" "1"
|
||||
"compatmanager_layer_name" "proton"
|
||||
}
|
||||
""" % LAUNCHER
|
||||
|
||||
|
||||
# Steam runs its own graphics probe through EVERY registered tool at once, ~40 s after logging in,
|
||||
# all with STEAM_COMPAT_DATA_PATH=.../compatdata/0, and those concurrent Protons can write their
|
||||
# builtin DLLs through each other's prefix links into each other's trees (seen: GE's FEX DLLs became
|
||||
# Proton Experimental's). Moving those runs to a prefix per tool was tried and crashed the Steam
|
||||
# client right after the probe started (segfault, rc 139, first ever in 25 sessions), so the client
|
||||
# relies on compatdata/0 itself. The launch-time check below is the protection instead.
|
||||
|
||||
# The Components page's choices, enforced in the one place every game launch passes: the app keeps
|
||||
# desired.tsv (tool dir, Proton build, component, file, sha256, source copy) and an unpacked copy of
|
||||
# each package in use. A file that no longer matches - whatever changed it - is put back before
|
||||
# Proton starts. Only for the Proton build the choice was made for: after a Steam update the build
|
||||
# differs and the Proton's own new files are left alone until the user chooses again.
|
||||
BL_COMPONENTS_SETUP = """
|
||||
bl_components() {
|
||||
base=$1
|
||||
cm_dir="${HOME:-/root}/.local/share/bannerlator-components"
|
||||
cm_list="$cm_dir/desired.tsv"
|
||||
# A real game launch only: the verb the client starts a game with and the game's own prefix. Every
|
||||
# other run - above all the client's own probes right after login, which all share compatdata/0 -
|
||||
# is left exactly as it was: with this check running through them, the client segfaulted (rc 139)
|
||||
# within seconds of starting its probes, four sessions out of four. The prefix decides rather than
|
||||
# the app id because a non-Steam shortcut launches with app id 0 but still gets a prefix of its own.
|
||||
[ "${verb:-}" = waitforexitandrun ] || return 0
|
||||
case "${STEAM_COMPAT_DATA_PATH:-}" in ''|*/compatdata/0|*/compatdata/0/|*/compatdata/0-*) return 0 ;; esac
|
||||
[ -f "$cm_list" ] || return 0
|
||||
cm_app=${STEAM_COMPAT_DATA_PATH%/}
|
||||
cm_app=${cm_app##*/}
|
||||
cm_tool=${base##*/}
|
||||
cm_build=$(awk 'NR == 1 { print $2 }' "$base/version" 2>/dev/null)
|
||||
cm_fixed=0
|
||||
cm_checked=0
|
||||
while IFS=$'\\t' read -r t want comp rel sum src; do
|
||||
[ "$t" = "$cm_tool" ] && [ "$want" = "$cm_build" ] || continue
|
||||
cm_checked=$((cm_checked + 1))
|
||||
f="$base/$rel"
|
||||
if [ -f "$f" ] && [ "$(sha256sum "$f" | cut -d' ' -f1)" = "$sum" ]; then continue; fi
|
||||
if [ ! -f "$src" ]; then
|
||||
echo "bannerlator-proton: components: $comp source missing ($src), left as it is" >&2
|
||||
continue
|
||||
fi
|
||||
mkdir -p "$(dirname "$f")"
|
||||
cp -f "$src" "$f.bl-new" && mv -f "$f.bl-new" "$f" || continue
|
||||
case "$rel" in *.so) chmod 755 "$f" ;; *) chmod 644 "$f" ;; esac
|
||||
cm_fixed=$((cm_fixed + 1))
|
||||
done < "$cm_list"
|
||||
[ "$cm_checked" -gt 0 ] && echo "bannerlator-proton: components: checked $cm_checked file(s) in $cm_tool for app $cm_app" >&2
|
||||
if [ "$cm_fixed" -gt 0 ]; then
|
||||
echo "bannerlator-proton: components: re-applied $cm_fixed of $cm_checked file(s) in $cm_tool before this launch" >&2
|
||||
printf '%s\\t%s\\t%s\\n' "$(date +%s)" "$cm_tool" "$cm_fixed" >> "$cm_dir/reapplied.log"
|
||||
fi
|
||||
}
|
||||
"""
|
||||
|
||||
# Resolves the depot at launch time, so the tool can be registered before the depot exists and
|
||||
# survives the client updating or replacing it. Proton takes its base directory from
|
||||
# dirname(sys.argv[0]) without resolving it, so it is run from the depot itself.
|
||||
# Cores for a game the client launches, kept separate from the client's own. One mask suits the
|
||||
# client's menus and another suits a game, and they are wanted at the same time - so the game's is
|
||||
# applied here, in the launch path every game goes through, rather than to the session as a whole.
|
||||
BL_GAME_CPUS_SETUP = """
|
||||
bl_game_cpus() {
|
||||
[ -n "${BL_GAME_CPUS:-}" ] || return 0
|
||||
command -v taskset >/dev/null 2>&1 || return 0
|
||||
# exec'd through taskset rather than set afterwards: a mask applied to a pid races the process
|
||||
# into spawning its own threads, and this way every thread inherits it from the first instruction.
|
||||
BL_TASKSET="taskset -c $BL_GAME_CPUS"
|
||||
echo "bannerlator-proton: game cores $BL_GAME_CPUS" >&2
|
||||
}
|
||||
"""
|
||||
|
||||
# Quake III engine games (id Tech 3) set their own resolution and switch the display to it. Under
|
||||
# gamescope with the ARM64 Proton that switch is refused ("calling CDS: failed, bad mode") and the
|
||||
# game never gets OpenGL; left at its own size in a window, it draws small in a corner. So these
|
||||
# titles are told to stay windowed at the session's own size - unless the user's launch options
|
||||
# already say something about the video mode, which are left as they are.
|
||||
# The session puts the client's own libraries (steamrtarm64, its panorama/) ahead of everything for
|
||||
# the client, and a game inherits that: Wine then resolved gnutls, SDL, FFmpeg and the rest against
|
||||
# the client's private copies instead of the rootfs it was built for. Inside Steam's runtime
|
||||
# container that path never reaches Proton either. (WinNative's winnative-proton-launch.)
|
||||
BL_LIBPATH_SETUP = """
|
||||
bl_libpath() {
|
||||
# A Proton built to prefer PipeWire (CachyOS's among the adopted ones) hung its audio thread
|
||||
# here, where only PulseAudio answers. (WinNative, winnative-proton-launch.)
|
||||
export PROTON_USE_PIPEWIRE=${PROTON_USE_PIPEWIRE:-0}
|
||||
[ -n "${LD_LIBRARY_PATH:-}" ] || return 0
|
||||
local kept= dir old_ifs=$IFS
|
||||
IFS=:
|
||||
for dir in $LD_LIBRARY_PATH; do
|
||||
case $dir in
|
||||
"" | */steamrtarm64 | */steamrtarm64/*) ;;
|
||||
*) kept=${kept:+$kept:}$dir ;;
|
||||
esac
|
||||
done
|
||||
IFS=$old_ifs
|
||||
if [ -n "$kept" ]; then export LD_LIBRARY_PATH="$kept"; else unset LD_LIBRARY_PATH; fi
|
||||
}
|
||||
"""
|
||||
|
||||
BL_IDTECH3_SETUP = """
|
||||
bl_idtech3() {
|
||||
BL_EXTRA_ARGS=()
|
||||
case "${SteamAppId:-${STEAM_COMPAT_APP_ID:-}}" in
|
||||
# Quake III Arena, Quake III: Team Arena, Return to Castle Wolfenstein, Jedi Academy.
|
||||
2200|2350|9010|6020) ;;
|
||||
*) return 0 ;;
|
||||
esac
|
||||
case " $* " in
|
||||
*r_fullscreen*|*r_mode*|*r_customwidth*|*r_customheight*)
|
||||
echo "bannerlator-proton: Quake-engine title; its launch options set the video mode, left as they are" >&2
|
||||
return 0 ;;
|
||||
esac
|
||||
w=${BL_WIDTH:-1280}
|
||||
h=${BL_HEIGHT:-720}
|
||||
BL_EXTRA_ARGS=(+set r_fullscreen 0 +set r_mode -1 +set r_customwidth "$w" +set r_customheight "$h")
|
||||
echo "bannerlator-proton: Quake-engine title: windowed at ${w}x${h}" >&2
|
||||
}
|
||||
"""
|
||||
|
||||
BL_DIRECTAUDIO_SETUP = """
|
||||
bl_directaudio() {
|
||||
base=$1
|
||||
[ -n "${BL_DIRECTAUDIO:-}" ] || return 0
|
||||
[ -d "$BL_DIRECTAUDIO/lib/wine" ] || return 0
|
||||
version=$("$base/files/bin-arm64/wine" --version 2>/dev/null)
|
||||
major=${version#wine-}
|
||||
major=${major%%.*}
|
||||
if [ "$major" != "11" ]; then
|
||||
echo "bannerlator-proton: DirectAudio left off - it is built for Wine 11 and this Proton is '${version:-unknown}'. Pairing them would be silent rather than broken, so it is not worth guessing." >&2
|
||||
return 0
|
||||
fi
|
||||
# Wine appends the per-architecture subdirectory to each entry, so the directory holding
|
||||
# aarch64-unix/ and aarch64-windows/ is what goes here.
|
||||
WINEDLLPATH="$BL_DIRECTAUDIO/lib/wine${WINEDLLPATH:+:$WINEDLLPATH}"
|
||||
export WINEDLLPATH
|
||||
# mmdevapi only tries the drivers named in the registry; its built-in list is pulse, alsa, oss and
|
||||
# coreaudio and knows nothing about this one. The key is appended to the prefix's user.reg rather
|
||||
# than written with `wine reg`, which would start a wineserver here just to set one value.
|
||||
reg="${STEAM_COMPAT_DATA_PATH:-}/pfx/user.reg"
|
||||
if [ -f "$reg" ]; then
|
||||
if ! grep -q '"Audio"="directaudio"' "$reg" 2>/dev/null; then
|
||||
printf '\n[Software\\\\Wine\\\\Drivers] %s\n"Audio"="directaudio"\n' "$(date +%s)" >> "$reg"
|
||||
echo "bannerlator-proton: DirectAudio selected in the prefix" >&2
|
||||
fi
|
||||
else
|
||||
# A prefix that does not exist yet is created by Proton moments from now, after this runs, so
|
||||
# the key lands on the NEXT launch of that game. Said out loud because silent audio on a first
|
||||
# launch would otherwise look like a fault.
|
||||
echo "bannerlator-proton: no prefix yet - DirectAudio takes effect the next time this game starts" >&2
|
||||
fi
|
||||
echo "bannerlator-proton: DirectAudio ready (Wine $major)" >&2
|
||||
}
|
||||
"""
|
||||
|
||||
# Resolves the depot at launch time, so the tool can be registered before the depot exists and
|
||||
# survives the client updating or replacing it. Proton takes its base directory from
|
||||
# dirname(sys.argv[0]) without resolving it, so it is run from the depot itself.
|
||||
LAUNCHER_SH = """#!/bin/bash
|
||||
# Bannerlator Proton (ARM64): runs the ARM64 Proton the Steam client downloaded, without the
|
||||
# Steam Linux Runtime container its own manifest asks for (no user namespaces on Android).
|
||||
verb=$1; shift
|
||||
steam_root=${STEAM_COMPAT_CLIENT_INSTALL_PATH:-${XDG_DATA_HOME:-$HOME/.local/share}/Steam}
|
||||
# Steam's overlay is preloaded into every game Valve launches, and used to be dropped here: it was
|
||||
# landing in front of open() and read() on /dev/input, letting Wine open the session's pad and
|
||||
# answering every read of it with nothing - a controller that never reports, and Wine's HID thread
|
||||
# spinning a core on it.
|
||||
#
|
||||
# Removing it was the wrong cure for an ordering problem. glibc processes LD_PRELOAD BEFORE
|
||||
# /etc/ld.so.preload, and the interposer lives in the latter, so the overlay was simply ahead of it.
|
||||
# Naming the interposer first in LD_PRELOAD puts it back in front and the overlay loads as Valve
|
||||
# intends. That matters beyond the overlay itself: every deviation from the launch Valve ships is a
|
||||
# difference this runtime would otherwise have to justify.
|
||||
fake=/usr/local/lib/libfakeinput.so
|
||||
if [ -f "$fake" ]; then
|
||||
case ":${LD_PRELOAD:-}:" in
|
||||
*":$fake:"*) ;;
|
||||
*) LD_PRELOAD="$fake${LD_PRELOAD:+:$LD_PRELOAD}"; export LD_PRELOAD ;;
|
||||
esac
|
||||
fi
|
||||
# The newest of the ARM64 depots the client has, by the build number that opens each one's version
|
||||
# file: taking the first one found ran a stale Experimental over a newer 11.0. (WinNative.)
|
||||
depot=
|
||||
best=0
|
||||
for name in %s; do
|
||||
for library in "$steam_root" /mnt/droiddeck-sd; do
|
||||
candidate="$library/steamapps/common/$name"
|
||||
[ -d "$candidate/files/bin-arm64" ] && [ -x "$candidate/proton" ] || continue
|
||||
build=0
|
||||
read -r build _ 2>/dev/null < "$candidate/version"
|
||||
case $build in "" | *[!0-9]*) build=0 ;; esac
|
||||
if [ -z "$depot" ] || [ "$build" -gt "$best" ]; then
|
||||
depot=$candidate
|
||||
best=$build
|
||||
fi
|
||||
done
|
||||
done
|
||||
if [ -n "$depot" ]; then
|
||||
bl_components "$depot"
|
||||
bl_directaudio "$depot"
|
||||
bl_game_cpus
|
||||
bl_idtech3 "$@"
|
||||
bl_libpath
|
||||
exec ${BL_TASKSET:-} /usr/local/bin/bannerlator-game-env "$depot/proton" "$verb" "$@" "${BL_EXTRA_ARGS[@]}"
|
||||
fi
|
||||
echo "bannerlator-proton: no ARM64 Proton depot yet - the client downloads one as this tool's dependency; retry the launch once it has" >&2
|
||||
exit 1
|
||||
""" % " ".join('"%s"' % n for n in SOURCES)
|
||||
# Spliced in after the formatting above, never through it: the function body contains ${major%%.*}
|
||||
# and a % format would eat that into a single %, leaving a shell expansion that silently does
|
||||
# something else.
|
||||
LAUNCHER_SH = LAUNCHER_SH.replace(
|
||||
"verb=$1; shift", "verb=$1; shift\n" + BL_DIRECTAUDIO_SETUP + BL_GAME_CPUS_SETUP + BL_IDTECH3_SETUP
|
||||
+ BL_COMPONENTS_SETUP + BL_LIBPATH_SETUP, 1)
|
||||
|
||||
# A third-party Proton dropped into compatibilitytools.d - GE-Proton, proton-cachyos, anything of
|
||||
# that shape - is adopted rather than used as shipped, for the same two reasons Valve's ARM64 depot
|
||||
# is: its manifest declares require_tool_appid, and the client's overlay library has to come out of
|
||||
# LD_PRELOAD. Its own entry point is left untouched and called through this wrapper.
|
||||
EXTRA_WRAPPER = "bannerlator-proton-wrap"
|
||||
EXTRA_MANIFEST_VDF = """"manifest"
|
||||
{
|
||||
"version" "2"
|
||||
"commandline" "/%s %%verb%%"
|
||||
"use_sessions" "1"
|
||||
"compatmanager_layer_name" "proton"
|
||||
}
|
||||
""" % EXTRA_WRAPPER
|
||||
# %s is the tool's own entry point, read out of the manifest it shipped with.
|
||||
EXTRA_WRAPPER_SH = """#!/bin/bash
|
||||
# Bannerlator: runs a Proton installed into compatibilitytools.d without the Steam Linux Runtime
|
||||
# container its own manifest asks for - pressure-vessel needs unprivileged user namespaces, which
|
||||
# an Android app does not get, and the launch dies before Proton is reached.
|
||||
verb=$1; shift
|
||||
here=$(dirname "$0")
|
||||
# See bannerlator-proton: the interposer goes first in LD_PRELOAD rather than the overlay being
|
||||
# removed, because glibc reads LD_PRELOAD before /etc/ld.so.preload and the overlay was simply
|
||||
# ahead of it on /dev/input.
|
||||
fake=/usr/local/lib/libfakeinput.so
|
||||
if [ -f "$fake" ]; then
|
||||
case ":${LD_PRELOAD:-}:" in
|
||||
*":$fake:"*) ;;
|
||||
*) LD_PRELOAD="$fake${LD_PRELOAD:+:$LD_PRELOAD}"; export LD_PRELOAD ;;
|
||||
esac
|
||||
fi
|
||||
bl_components "$here"
|
||||
bl_directaudio "$here"
|
||||
bl_game_cpus
|
||||
bl_idtech3 "$@"
|
||||
bl_libpath
|
||||
# Proton takes its base directory from dirname(sys.argv[0]) without resolving it, so it has to be
|
||||
# started from its own tree.
|
||||
exec ${BL_TASKSET:-} /usr/local/bin/bannerlator-game-env "$here/%s" "$verb" "$@" "${BL_EXTRA_ARGS[@]}"
|
||||
"""
|
||||
EXTRA_COMPAT_TOOL_VDF = """"compatibilitytools"
|
||||
{
|
||||
"compat_tools"
|
||||
{
|
||||
"%s"
|
||||
{
|
||||
"install_path" "."
|
||||
"display_name" "%s (Bannerlator)"
|
||||
"from_oslist" "windows"
|
||||
"to_oslist" "linux"
|
||||
}
|
||||
}
|
||||
}
|
||||
"""
|
||||
|
||||
|
||||
TOKEN = re.compile(r'\s*(?:"((?:[^"\\]|\\.)*)"|([{}])|//[^\n]*)')
|
||||
|
||||
|
||||
def tokenize(text):
|
||||
tokens = []
|
||||
pos = 0
|
||||
while pos < len(text):
|
||||
m = TOKEN.match(text, pos)
|
||||
if not m or m.end() == pos:
|
||||
break
|
||||
pos = m.end()
|
||||
if m.group(2):
|
||||
tokens.append(m.group(2))
|
||||
elif m.group(1) is not None:
|
||||
tokens.append('"' + m.group(1) + '"')
|
||||
return tokens
|
||||
|
||||
|
||||
def find_block(tokens, path):
|
||||
"""Index of the '{' opening the block at path, or None."""
|
||||
depth, want, i = 0, 0, 0
|
||||
while i < len(tokens):
|
||||
t = tokens[i]
|
||||
if t == "{":
|
||||
depth += 1
|
||||
elif t == "}":
|
||||
depth -= 1
|
||||
if depth < want:
|
||||
return None
|
||||
elif depth == want and i + 1 < len(tokens) and tokens[i + 1] == "{":
|
||||
if t.lower() == '"%s"' % path[want].lower():
|
||||
if want == len(path) - 1:
|
||||
return i + 1
|
||||
want += 1
|
||||
i += 1
|
||||
return None
|
||||
|
||||
|
||||
def block_end(tokens, start):
|
||||
depth = 0
|
||||
for i in range(start, len(tokens)):
|
||||
if tokens[i] == "{":
|
||||
depth += 1
|
||||
elif tokens[i] == "}":
|
||||
depth -= 1
|
||||
if depth == 0:
|
||||
return i
|
||||
return len(tokens)
|
||||
|
||||
|
||||
def serialize(tokens):
|
||||
out, depth, i = [], 0, 0
|
||||
while i < len(tokens):
|
||||
t = tokens[i]
|
||||
if t == "}":
|
||||
depth -= 1
|
||||
out.append("\t" * depth + "}")
|
||||
i += 1
|
||||
elif i + 1 < len(tokens) and tokens[i + 1] == "{":
|
||||
out.append("\t" * depth + t)
|
||||
out.append("\t" * depth + "{")
|
||||
depth += 1
|
||||
i += 2
|
||||
else:
|
||||
out.append("\t" * depth + t + "\t\t" + tokens[i + 1])
|
||||
i += 2
|
||||
return "\n".join(out) + "\n"
|
||||
|
||||
|
||||
def write_changed(path, text, mode=None):
|
||||
"""Writes `text` to `path` only when it differs, through a rename so a reader never sees half a
|
||||
file. The session runs this script every 15 s for as long as the client does; rewriting files
|
||||
that have not changed cost a python start's worth of writes each time, and config.vdf is the
|
||||
client's own, which it may be writing at that moment. Returns whether anything was written."""
|
||||
try:
|
||||
with open(path, encoding="utf-8", errors="replace") as f:
|
||||
same = f.read() == text
|
||||
except OSError:
|
||||
same = False
|
||||
if not same:
|
||||
tmp = path + ".bannerlator"
|
||||
with open(tmp, "w", encoding="utf-8") as f:
|
||||
f.write(text)
|
||||
if mode is not None:
|
||||
os.chmod(tmp, mode)
|
||||
os.replace(tmp, path)
|
||||
elif mode is not None and (os.stat(path).st_mode & 0o7777) != mode:
|
||||
os.chmod(path, mode)
|
||||
return not same
|
||||
|
||||
|
||||
def first_key(path, section):
|
||||
"""The single key naming a block inside `section`, or None. Used to keep a third-party tool's
|
||||
own internal name, so a mapping the user already made against it keeps working."""
|
||||
try:
|
||||
with open(path, encoding="utf-8", errors="replace") as f:
|
||||
tokens = tokenize(f.read())
|
||||
except OSError:
|
||||
return None
|
||||
block = find_block(tokens, section)
|
||||
if block is None:
|
||||
return None
|
||||
for i in range(block + 1, block_end(tokens, block)):
|
||||
if tokens[i] == "}":
|
||||
break
|
||||
if i + 1 < len(tokens) and tokens[i + 1] == "{":
|
||||
return tokens[i].strip('"')
|
||||
return None
|
||||
|
||||
|
||||
def manifest_entry_point(path):
|
||||
"""The script a toolmanifest's commandline runs, relative to the tool directory."""
|
||||
try:
|
||||
with open(path, encoding="utf-8", errors="replace") as f:
|
||||
tokens = tokenize(f.read())
|
||||
except OSError:
|
||||
return None
|
||||
for i in range(len(tokens) - 1):
|
||||
if tokens[i].lower() == '"commandline"':
|
||||
command = tokens[i + 1].strip('"').split()
|
||||
if command:
|
||||
return command[0].lstrip("/")
|
||||
return None
|
||||
|
||||
|
||||
def adopt_extras(tools):
|
||||
"""Makes every other Proton in compatibilitytools.d launchable here, and returns the tool names
|
||||
to leave alone in CompatToolMapping - the whole point of installing one is to pick it per game,
|
||||
so register_default must not repoint it back at ours."""
|
||||
adopted = {}
|
||||
try:
|
||||
entries = sorted(os.listdir(tools))
|
||||
except OSError:
|
||||
return adopted
|
||||
for entry in entries:
|
||||
if entry == TOOL or entry.startswith("."):
|
||||
continue
|
||||
tool_dir = os.path.join(tools, entry)
|
||||
manifest = os.path.join(tool_dir, "toolmanifest.vdf")
|
||||
if not os.path.isdir(tool_dir) or not os.path.isfile(manifest):
|
||||
continue
|
||||
# The shipped manifest is kept, once, and stays the source of the entry point: re-running
|
||||
# must not read back our own rewritten commandline and wrap the wrapper.
|
||||
original = manifest + ".bannerlator-orig"
|
||||
if not os.path.isfile(original):
|
||||
try:
|
||||
shutil.copy2(manifest, original)
|
||||
except OSError:
|
||||
continue
|
||||
entry_point = manifest_entry_point(original)
|
||||
if not entry_point or entry_point == EXTRA_WRAPPER:
|
||||
entry_point = "proton"
|
||||
if not os.path.exists(os.path.join(tool_dir, entry_point)):
|
||||
print("bannerlator-steam-compat: %s has no %s; left alone" % (entry, entry_point))
|
||||
continue
|
||||
compat_vdf = os.path.join(tool_dir, "compatibilitytool.vdf")
|
||||
name = first_key(compat_vdf, ["compatibilitytools", "compat_tools"]) or entry
|
||||
wrapper = os.path.join(tool_dir, EXTRA_WRAPPER)
|
||||
try:
|
||||
# Formatted first, spliced second: the function carries a printf %s and a
|
||||
# ${major%%.*} of its own, and putting it through the format would eat both.
|
||||
body = (EXTRA_WRAPPER_SH % entry_point).replace(
|
||||
'here=$(dirname "$0")',
|
||||
'here=$(dirname "$0")\n' + BL_DIRECTAUDIO_SETUP + BL_GAME_CPUS_SETUP + BL_IDTECH3_SETUP
|
||||
+ BL_COMPONENTS_SETUP + BL_LIBPATH_SETUP, 1)
|
||||
write_changed(wrapper, body, 0o755)
|
||||
write_changed(manifest, EXTRA_MANIFEST_VDF)
|
||||
write_changed(compat_vdf, EXTRA_COMPAT_TOOL_VDF % (name, entry))
|
||||
except OSError as e:
|
||||
print("bannerlator-steam-compat: could not adopt %s (%s)" % (entry, e))
|
||||
continue
|
||||
adopted[name] = entry
|
||||
return adopted
|
||||
|
||||
|
||||
# Steam's own tools and runtimes live in steamapps beside the games; they are not titles and must
|
||||
# not be mapped to a compatibility tool.
|
||||
NOT_GAMES = frozenset((
|
||||
"228980", # Steamworks Common Redistributables
|
||||
"1070560", # Steam Linux Runtime 1.0 (scout)
|
||||
"1391110", # Steam Linux Runtime 2.0 (soldier)
|
||||
"1493710", # Proton Experimental
|
||||
"3127680", # FEX
|
||||
"4183110", # Steam Linux Runtime 4.0
|
||||
"4185400", # Steam Linux Runtime 4.0 - Arm64
|
||||
"4427310", # Proton Experimental (ARM64)
|
||||
"4628740", # Proton 11.0 (ARM64)
|
||||
))
|
||||
|
||||
|
||||
def installed_apps(steam_root):
|
||||
"""App ids of the titles the client has installed, tools and runtimes excluded."""
|
||||
apps = set()
|
||||
for library in (steam_root, LIBRARY + "-sd"):
|
||||
steamapps = os.path.join(library, "steamapps")
|
||||
try:
|
||||
names = os.listdir(steamapps)
|
||||
except OSError:
|
||||
continue
|
||||
for name in names:
|
||||
m = re.fullmatch(r"appmanifest_(\d+)\.acf", name)
|
||||
if m and m.group(1) not in NOT_GAMES:
|
||||
apps.add(m.group(1))
|
||||
return sorted(apps, key=int)
|
||||
|
||||
|
||||
def register_default(config_path, apps=(), name=None, protect=()):
|
||||
"""Writes the mapping. `name` defaults to our own tool; the first-run seed passes Valve's."""
|
||||
tool = name or TOOL
|
||||
# Tool names the user may deliberately have chosen (see adopt_extras); never repointed.
|
||||
keep = {n.lower() for n in protect}
|
||||
with open(config_path, encoding="utf-8", errors="replace") as f:
|
||||
original = f.read()
|
||||
tokens = tokenize(original)
|
||||
steam = find_block(tokens, ["InstallConfigStore", "Software", "Valve", "Steam"])
|
||||
if steam is None:
|
||||
return
|
||||
mapping = find_block(tokens[steam + 1:], ["CompatToolMapping"])
|
||||
entry = ['"0"', "{", '"name"', '"%s"' % tool, '"config"', '""', '"priority"', '"75"', "}"]
|
||||
if mapping is None:
|
||||
end = block_end(tokens, steam)
|
||||
tokens[end:end] = ['"CompatToolMapping"', "{"] + entry + ["}"]
|
||||
else:
|
||||
mapping += steam + 1
|
||||
# Repoint every per-app entry the client aimed at a Proton it cannot actually start.
|
||||
for i in range(mapping, block_end(tokens, mapping)):
|
||||
named = tokens[i + 1].strip('"').lower()
|
||||
if (tokens[i] == '"name"' and named.startswith("proton")
|
||||
and named != tool.lower() and named not in keep):
|
||||
tokens[i + 1] = '"%s"' % tool
|
||||
if find_block(tokens[mapping + 1:], ["0"]) is None:
|
||||
tokens[mapping + 1:mapping + 1] = entry
|
||||
# The "0" default only decides how a title is installed, so it settles new downloads and
|
||||
# leaves anything already installed as a Linux build running as one. An entry per installed
|
||||
# app is what the client's own Compatibility checkbox writes, and is what makes it switch.
|
||||
for app in apps:
|
||||
if find_block(tokens[mapping + 1:], [app]) is not None:
|
||||
continue
|
||||
tokens[mapping + 1:mapping + 1] = [
|
||||
'"%s"' % app, "{", '"name"', '"%s"' % tool, '"config"', '""', '"priority"', '"250"', "}"]
|
||||
# Nothing to change is the usual case on the session's beat: the client's own file is left alone.
|
||||
text = serialize(tokens)
|
||||
if text != serialize(tokenize(original)):
|
||||
write_changed(config_path, text)
|
||||
|
||||
|
||||
def depot_build(depot):
|
||||
"""The build number a depot's version file starts with; 0 when there is none."""
|
||||
try:
|
||||
with open(os.path.join(depot, "version"), encoding="utf-8", errors="replace") as f:
|
||||
first = f.read().split(None, 1)
|
||||
except OSError:
|
||||
return 0
|
||||
return int(first[0]) if first and first[0].isdigit() else 0
|
||||
|
||||
|
||||
def find_source(steam_root):
|
||||
"""The newest ARM64 Proton depot the client has downloaded (the one the launcher runs), or None."""
|
||||
# bin-arm64 is what makes it the native build rather than the x86_64 one.
|
||||
found = [os.path.join(root, "steamapps", "common", name)
|
||||
for root in (steam_root, "/mnt/droiddeck-sd") for name in SOURCES
|
||||
if os.path.isdir(os.path.join(root, "steamapps", "common", name, "files", "bin-arm64"))]
|
||||
return max(found, key=depot_build) if found else None
|
||||
|
||||
|
||||
def build_tool(tool_dir):
|
||||
"""Our own manifests and the launcher. The depot is found at launch time, not here."""
|
||||
if os.path.islink(tool_dir):
|
||||
os.unlink(tool_dir)
|
||||
elif os.path.isdir(tool_dir) and set(os.listdir(tool_dir)) - set(OWN_FILES):
|
||||
# Earlier versions mirrored the depot in here as symlinks; start clean. A directory holding
|
||||
# only our own files is kept, and each file rewritten only when it changed.
|
||||
shutil.rmtree(tool_dir)
|
||||
os.makedirs(tool_dir, exist_ok=True)
|
||||
write_changed(os.path.join(tool_dir, "toolmanifest.vdf"), TOOL_MANIFEST_VDF)
|
||||
write_changed(os.path.join(tool_dir, "compatibilitytool.vdf"), COMPAT_TOOL_VDF % TOOL)
|
||||
write_changed(os.path.join(tool_dir, LAUNCHER), LAUNCHER_SH, 0o755)
|
||||
|
||||
|
||||
def main():
|
||||
steam_root = sys.argv[1]
|
||||
tools = os.path.join(steam_root, "compatibilitytools.d")
|
||||
os.makedirs(tools, exist_ok=True)
|
||||
build_tool(os.path.join(tools, TOOL))
|
||||
extras = adopt_extras(tools)
|
||||
for name, directory in sorted(extras.items()):
|
||||
print("bannerlator-steam-compat: adopted %s as %s" % (directory, name))
|
||||
depot = find_source(steam_root)
|
||||
print("bannerlator-steam-compat: registered %s (%s)" % (
|
||||
TOOL, "depot %s present" % os.path.basename(depot) if depot else
|
||||
"no ARM64 Proton depot yet; the session asks the client to fetch it"))
|
||||
config = os.path.join(steam_root, "config", "config.vdf")
|
||||
if os.path.isfile(config):
|
||||
apps = installed_apps(steam_root)
|
||||
register_default(config, apps, protect=extras)
|
||||
print("bannerlator-steam-compat: default and %d installed title(s) set to %s" % (len(apps), TOOL))
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
+122
@@ -0,0 +1,122 @@
|
||||
#!/bin/bash
|
||||
# An AppImage imported from the front end (AppImageManager), extracted once at import into
|
||||
# /opt/appimages/user/<id>/app
|
||||
# and started from there: proot has no FUSE to mount the image, and extracting it at every
|
||||
# start (APPIMAGE_EXTRACT_AND_RUN) would cost the whole image in /tmp each time.
|
||||
# droiddeck-appimage-run /opt/appimages/user/<id> [args...]
|
||||
set -u
|
||||
dir=${1:?usage: droiddeck-appimage-run <imported AppImage directory> [args...]}
|
||||
shift
|
||||
export APPDIR=$dir/app
|
||||
# APPIMAGE is left unset on purpose: with it an app believes it runs from an image file and offers
|
||||
# to add itself to the menu (DuckStation) or update the file in place - DroidDeck already does the
|
||||
# one, and there is no image file for the other.
|
||||
unset APPIMAGE
|
||||
export ARGV0=$(cat "$dir/name" 2>/dev/null || basename "$dir")
|
||||
if [ ! -x "$APPDIR/AppRun" ]; then
|
||||
echo "droiddeck-appimage-run: $APPDIR/AppRun is missing; import the AppImage again" >&2
|
||||
exit 127
|
||||
fi
|
||||
# Browsers sandbox their own children with namespaces and a setuid helper, neither of which proot
|
||||
# can give them (the Flatpak sandboxes get the same; see BwrapSpawner): Firefox and its forks (Zen,
|
||||
# LibreWolf) by these switches, Electron and Chromium builds by --no-sandbox. Chromium on Wayland
|
||||
# also asks the render node for a DRM version KGSL cannot give, so with an X server up it stays on
|
||||
# X11, which it picks from the session type.
|
||||
export MOZ_DISABLE_CONTENT_SANDBOX=1 MOZ_DISABLE_GMP_SANDBOX=1 MOZ_DISABLE_RDD_SANDBOX=1
|
||||
export MOZ_DISABLE_SOCKET_PROCESS_SANDBOX=1 MOZ_DISABLE_UTILITY_SANDBOX=1
|
||||
# sharun images start the app through their own ld.so, patched not to read /etc/ld.so.preload, and
|
||||
# drop LD_PRELOAD unless allowed: without this the app never gets the session's pads.
|
||||
if [ -s /etc/ld.so.preload ]; then
|
||||
preload=$(tr -s '\n' ':' < /etc/ld.so.preload)
|
||||
export LD_PRELOAD="${preload%:}${LD_PRELOAD:+:$LD_PRELOAD}" SHARUN_ALLOW_LD_PRELOAD=1
|
||||
fi
|
||||
flags=()
|
||||
if [ -e "$APPDIR/chrome-sandbox" ] || compgen -G "$APPDIR/*/chrome-sandbox" >/dev/null; then
|
||||
flags+=(--no-sandbox)
|
||||
if [ -n "${DISPLAY:-}" ]; then
|
||||
export XDG_SESSION_TYPE=x11
|
||||
unset WAYLAND_DISPLAY
|
||||
flags+=(--ozone-platform=x11)
|
||||
fi
|
||||
fi
|
||||
qt=$(cat "$dir/qt" 2>/dev/null)
|
||||
case $qt in wayland|xcb) ;; *) qt=auto ;; esac
|
||||
wayland=${GAMESCOPE_WAYLAND_DISPLAY:-${WAYLAND_DISPLAY:-}}
|
||||
if [ "$qt" = auto ] && [ -n "$wayland" ]; then
|
||||
bundled=$(find "$APPDIR" -maxdepth 6 \( -name 'libQt6Quick.so.6*' -o -name libvulkan.so.1 -o -name 'libqwayland*.so' \) -printf '%f\n' 2>/dev/null)
|
||||
if grep -q '^libQt6Quick\.so\.6' <<<"$bundled"; then
|
||||
if grep -q '^libqwayland' <<<"$bundled" \
|
||||
&& { grep -qx libvulkan.so.1 <<<"$bundled" || grep -qs QVulkanInstance "$APPDIR"/usr/bin/* "$APPDIR"/bin/*; }; then
|
||||
qt=wayland
|
||||
else
|
||||
echo "== appimage: Qt Quick without Vulkan or Qt's Wayland plugin stays on X11 ($(tr '\n' ' ' <<<"$bundled"))"
|
||||
fi
|
||||
fi
|
||||
fi
|
||||
if [ "$qt" = wayland ] && [ -n "$wayland" ]; then
|
||||
export QT_QPA_PLATFORM='wayland;xcb' WAYLAND_DISPLAY=$wayland SDL_VIDEODRIVER=wayland XDG_SESSION_TYPE=wayland
|
||||
[ "$wayland" = "${GAMESCOPE_WAYLAND_DISPLAY:-}" ] && export QT_WAYLAND_DISABLE_WINDOWDECORATION=1 DISABLE_GAMESCOPE_WSI=1
|
||||
elif [ "$qt" = xcb ] && [ -n "${DISPLAY:-}" ]; then
|
||||
export QT_QPA_PLATFORM=xcb
|
||||
fi
|
||||
fex=$(cat "$dir/fex" 2>/dev/null)
|
||||
case $fex in on|off) ;; *) fex=auto ;; esac
|
||||
run=("$APPDIR/AppRun")
|
||||
if [ -x /usr/local/bin/droiddeck-fex ]; then
|
||||
case $fex:$(cat "$dir/arch" 2>/dev/null) in
|
||||
auto:x86_64|auto:i386) run=(/usr/local/bin/droiddeck-fex run --mode on -- "$APPDIR/AppRun") ;;
|
||||
auto:arm64) ;;
|
||||
*) run=(/usr/local/bin/droiddeck-fex run --mode "$fex" --for "$APPDIR" -- "$APPDIR/AppRun") ;;
|
||||
esac
|
||||
fi
|
||||
echo "== appimage $ARGV0 ($APPDIR) ${flags[*]} FEX $fex Qt $qt${QT_QPA_PLATFORM:+ ($QT_QPA_PLATFORM)}"
|
||||
cd "$APPDIR" || exit 1
|
||||
started=$(mktemp "${TMPDIR:-/tmp}/droiddeck-appimage.XXXXXX")
|
||||
# Apps expect a session bus; Electron's main process traps (SIGTRAP) on an address it cannot
|
||||
# parse. A run mode has none, so one is started for the app, as for Flatpak apps.
|
||||
case ${DBUS_SESSION_BUS_ADDRESS:-} in
|
||||
unix:*) "${run[@]}" "${flags[@]}" "$@" ;;
|
||||
*) unset DBUS_SESSION_BUS_ADDRESS
|
||||
if command -v dbus-run-session >/dev/null 2>&1; then
|
||||
dbus-run-session -- "${run[@]}" "${flags[@]}" "$@"
|
||||
else
|
||||
"${run[@]}" "${flags[@]}" "$@"
|
||||
fi ;;
|
||||
esac
|
||||
rc=$?
|
||||
if [ "$rc" -gt 128 ]; then
|
||||
echo "== appimage $ARGV0: ended by signal $((rc - 128)) ($(kill -l $((rc - 128)) 2>/dev/null))"
|
||||
else
|
||||
echo "== appimage $ARGV0: exited with status $rc"
|
||||
fi
|
||||
if [ "$rc" -ne 0 ] && [ -n "$started" ]; then
|
||||
find "${HOME:-/root}/.local/share" "${HOME:-/root}/.config" "${HOME:-/root}/.cache" -maxdepth 4 -type f \
|
||||
\( -iname '*.log' -o -iname '*log*.txt' \) -newer "$started" -size -64M 2>/dev/null | head -n 3 |
|
||||
while IFS= read -r log; do
|
||||
echo "== appimage $ARGV0: end of $log"
|
||||
tail -n 40 "$log" | LC_ALL=C tr -cd '\11\12\40-\176' | cut -c1-400
|
||||
done
|
||||
fi
|
||||
rm -f "$started"
|
||||
# The program a session was started for may hand over to another process and exit: Electron apps
|
||||
# relaunch themselves (Obsidian on its first start), launchers fork their real program. The
|
||||
# session ends with this script, and takes the rest with it - so it waits while anything running
|
||||
# from the image is still up.
|
||||
image_running() {
|
||||
local p exe arg cwd
|
||||
for p in /proc/[0-9]*; do
|
||||
exe=$(readlink "$p/exe" 2>/dev/null) || continue
|
||||
case $exe in "$APPDIR"/*) return 0 ;; esac
|
||||
case $exe in
|
||||
*/FEX|*/FEXInterpreter)
|
||||
arg=$(tr '\0' '\n' < "$p/cmdline" 2>/dev/null | sed -n 2p)
|
||||
cwd=$(readlink "$p/cwd" 2>/dev/null)
|
||||
case $arg in "$APPDIR"/*) return 0 ;; esac
|
||||
case $cwd in "$APPDIR"|"$APPDIR"/*) return 0 ;; esac
|
||||
;;
|
||||
esac
|
||||
done
|
||||
return 1
|
||||
}
|
||||
while image_running; do sleep 2; done
|
||||
exit $rc
|
||||
File renamed without changes.
File renamed without changes.
+3
-3
@@ -4,7 +4,7 @@
|
||||
# the app - so an entry of ours exists only for a game the client wrote none for. Plus two links in
|
||||
# the home folder to the game files. Run at every desktop start; stale entries go.
|
||||
#
|
||||
# bannerlator-desktop-games [steam root]
|
||||
# droiddeck-desktop-games [steam root]
|
||||
import os
|
||||
import re
|
||||
import sys
|
||||
@@ -90,7 +90,7 @@ def write_entries():
|
||||
safe = name.replace("\n", " ").strip() or str(appid)
|
||||
body = (
|
||||
"[Desktop Entry]\nType=Application\nName=%s\nComment=Steam game %d - opens in Steam under gamescope\n"
|
||||
"Exec=/usr/local/bin/bannerlator-steam-launch desktop %d\nIcon=%s\nTerminal=false\n"
|
||||
"Exec=/usr/local/bin/droiddeck-steam-launch desktop %d\nIcon=%s\nTerminal=false\n"
|
||||
"Categories=Game;\nX-DroidDeck-AppId=%d\n" % (safe, appid, appid, icon_for(appid), appid)
|
||||
)
|
||||
path = os.path.join(APPS_DIR, "%s%d.desktop" % (PREFIX, appid))
|
||||
@@ -123,7 +123,7 @@ def link_libraries():
|
||||
def main():
|
||||
wanted = write_entries()
|
||||
link_libraries()
|
||||
print("bannerlator-desktop-games: %d entr%s of ours, %d the client's" % (
|
||||
print("droiddeck-desktop-games: %d entr%s of ours, %d the client's" % (
|
||||
len(wanted), "y" if len(wanted) == 1 else "ies", len(client_entries())))
|
||||
|
||||
|
||||
@@ -364,11 +364,21 @@ def load_packs(root):
|
||||
return packs
|
||||
|
||||
|
||||
def line_epoch(line):
|
||||
fields = (line or "").split()
|
||||
try:
|
||||
return int(fields[0]) if fields else 0
|
||||
except ValueError:
|
||||
return 0
|
||||
|
||||
|
||||
def match_kind(pack, measured):
|
||||
if pack.get("revoked") or pack.get("ignored") or measured["builtin"]:
|
||||
return None
|
||||
stock = pack["stock"]
|
||||
if stock[NTDLL] == measured["ntdll"] and stock[WINESERVER] == measured["wineserver"]:
|
||||
if pack.get("version") != measured["token"] and line_epoch(pack.get("version_line")) > line_epoch(measured["version_line"]) > 0:
|
||||
return None
|
||||
return "exact"
|
||||
if (pack.get("source_match") is True and measured["token"] and pack.get("version") == measured["token"]
|
||||
and pack.get("exports") == measured["exports"]):
|
||||
@@ -383,7 +393,7 @@ def find_pack(packs, measured):
|
||||
kind = match_kind(pack, measured)
|
||||
if kind is None:
|
||||
continue
|
||||
key = (kind == "exact", pack["rev"], pack["id"])
|
||||
key = (kind == "exact", bool(measured["token"]) and pack.get("version") == measured["token"], pack["rev"], pack["id"])
|
||||
if best_key is None or key > best_key:
|
||||
best, best_key = pack, key
|
||||
return best
|
||||
@@ -789,6 +799,18 @@ def keep_live(root, command, env, tool):
|
||||
return None
|
||||
if not os.path.isfile(kept_command) or not server_running(prefix):
|
||||
return None
|
||||
kept_pack = row["env"].get("BL_SYNC_PACK")
|
||||
if isinstance(kept_pack, str) and kept_pack and command[1:2] == ["waitforexitandrun"]:
|
||||
try:
|
||||
cache = HashCache(root)
|
||||
try:
|
||||
pack = find_pack(load_packs(root), measure(tool, cache))
|
||||
finally:
|
||||
cache.save()
|
||||
except (OSError, ValueError):
|
||||
pack = {"id": kept_pack}
|
||||
if pack is None or pack["id"] != kept_pack:
|
||||
return None
|
||||
command, env = list(command), dict(env)
|
||||
command[0] = kept_command
|
||||
for name in LIVE_KEYS:
|
||||
|
||||
+659
@@ -0,0 +1,659 @@
|
||||
#!/usr/bin/python3
|
||||
import contextlib
|
||||
import fcntl
|
||||
import filecmp
|
||||
import gzip
|
||||
import json
|
||||
import os
|
||||
import re
|
||||
import runpy
|
||||
import shutil
|
||||
import struct
|
||||
import subprocess
|
||||
import sys
|
||||
|
||||
HOME = os.environ.get("HOME") or "/root"
|
||||
STEAM_ROOT = os.path.join(HOME, ".local", "share", "Steam")
|
||||
LIBRARIES = ("/mnt/droiddeck", "/mnt/droiddeck-sd")
|
||||
STATE = os.path.join(HOME, ".local", "share", "droiddeck-fex")
|
||||
CONFIG_DIR = os.path.join(STATE, "config")
|
||||
DATA_DIR = os.path.join(STATE, "data")
|
||||
CACHE_DIR = os.path.join(HOME, ".cache", "droiddeck-fex")
|
||||
STATUS_FILE = os.path.join(STATE, "status.json")
|
||||
WANTED = os.path.join(HOME, ".config", "droiddeck", "fex-wanted")
|
||||
GAME_ENVIRONMENT = os.path.join(HOME, ".config", "droiddeck", "game-environment.json")
|
||||
BIN_DIR = os.path.dirname(os.path.abspath(__file__))
|
||||
PRELOADS = "/usr/local/lib/droiddeck-fex"
|
||||
URUNTIME = "/usr/local/lib/droiddeck/uruntime"
|
||||
HOST_PRELOAD = "/etc/ld.so.preload"
|
||||
FEX_APPID = "3127680"
|
||||
SNIPER_APPID = "1628350"
|
||||
INSTALL_DIRS = {FEX_APPID: "FEX-Emu", SNIPER_APPID: "SteamLinuxRuntime_sniper"}
|
||||
MARKER = ".droiddeck-fex"
|
||||
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"
|
||||
VULKAN_THUNK = "libvulkan-guest.so"
|
||||
RUNTIME_LIBRARIES = (("libc.so.6", b"GLIBC_"), ("libstdc++.so.6", b"GLIBCXX_"))
|
||||
VERSION_NAME = re.compile(rb"GLIBC(?:XX)?_[0-9][0-9.]*[0-9]")
|
||||
BUNDLE_DEPTH = 3
|
||||
THUNKS = {"GL": 1, "Vulkan": 1}
|
||||
X86 = {3: "i386", 62: "x86_64"}
|
||||
ARM = {40: "arm", 183: "arm64"}
|
||||
SCAN_DEPTH = 4
|
||||
SCAN_LIMIT = 4000
|
||||
MODES = ("auto", "on", "off")
|
||||
STEAM_VERBS = ("run", "waitforexitandrun")
|
||||
ESCAPE = re.compile(rb"\\([0-7]{3})")
|
||||
|
||||
|
||||
def say(message):
|
||||
print("droiddeck-fex: %s" % message, file=sys.stderr, flush=True)
|
||||
|
||||
|
||||
def read_text(path):
|
||||
try:
|
||||
with open(path, encoding="utf-8", errors="replace") as f:
|
||||
return f.read()
|
||||
except OSError:
|
||||
return None
|
||||
|
||||
|
||||
def write_if_changed(path, data, mode=0o644):
|
||||
if isinstance(data, str):
|
||||
data = data.encode("utf-8")
|
||||
try:
|
||||
with open(path, "rb") as f:
|
||||
if f.read() == data:
|
||||
return False
|
||||
except OSError:
|
||||
pass
|
||||
os.makedirs(os.path.dirname(path), exist_ok=True)
|
||||
tmp = "%s.%d.tmp" % (path, os.getpid())
|
||||
with open(tmp, "wb") as f:
|
||||
f.write(data)
|
||||
os.chmod(tmp, mode)
|
||||
os.replace(tmp, path)
|
||||
return True
|
||||
|
||||
|
||||
def copy_if_changed(source, target):
|
||||
if os.path.isfile(target) and filecmp.cmp(source, target, shallow=False):
|
||||
return False
|
||||
os.makedirs(os.path.dirname(target), exist_ok=True)
|
||||
tmp = "%s.%d.tmp" % (target, os.getpid())
|
||||
shutil.copyfile(source, tmp)
|
||||
os.chmod(tmp, 0o755)
|
||||
os.replace(tmp, target)
|
||||
return True
|
||||
|
||||
|
||||
@contextlib.contextmanager
|
||||
def locked():
|
||||
os.makedirs(STATE, exist_ok=True)
|
||||
with open(os.path.join(STATE, "lock"), "w") as handle:
|
||||
fcntl.flock(handle, fcntl.LOCK_EX)
|
||||
try:
|
||||
yield
|
||||
finally:
|
||||
fcntl.flock(handle, fcntl.LOCK_UN)
|
||||
|
||||
|
||||
def libraries():
|
||||
roots = [STEAM_ROOT]
|
||||
text = read_text(os.path.join(STEAM_ROOT, "steamapps", "libraryfolders.vdf")) or ""
|
||||
roots += [path.replace("\\\\", "\\") for path in re.findall(r'"path"\s+"((?:[^"\\]|\\.)*)"', text)]
|
||||
roots += LIBRARIES
|
||||
seen, found = set(), []
|
||||
for root in roots:
|
||||
real = os.path.realpath(root)
|
||||
if real not in seen and os.path.isdir(os.path.join(root, "steamapps")):
|
||||
seen.add(real)
|
||||
found.append(root)
|
||||
return found
|
||||
|
||||
|
||||
def app_dir(appid):
|
||||
for library in libraries():
|
||||
steamapps = os.path.join(library, "steamapps")
|
||||
match = re.search(r'"installdir"\s+"([^"]+)"', read_text(os.path.join(steamapps, "appmanifest_%s.acf" % appid)) or "")
|
||||
for name in filter(None, (match.group(1) if match else None, INSTALL_DIRS.get(appid))):
|
||||
path = os.path.join(steamapps, "common", name)
|
||||
if os.path.isdir(path):
|
||||
return path
|
||||
return None
|
||||
|
||||
|
||||
def first_dir(prefix, candidates):
|
||||
for candidate in candidates:
|
||||
path = os.path.join(prefix, candidate)
|
||||
if os.path.isdir(path):
|
||||
return path
|
||||
return None
|
||||
|
||||
|
||||
def fex_install():
|
||||
prefixes = []
|
||||
tool = app_dir(FEX_APPID)
|
||||
if tool:
|
||||
prefixes += [(os.path.join(tool, sub), True) for sub in ("usr", "", "files/usr", "files")]
|
||||
prefixes.append(("/usr", False))
|
||||
for prefix, portable in prefixes:
|
||||
binary = next((os.path.join(prefix, "bin", name) for name in ("FEX", "FEXInterpreter")
|
||||
if os.access(os.path.join(prefix, "bin", name), os.X_OK)), None)
|
||||
if not binary:
|
||||
continue
|
||||
server = os.path.join(prefix, "bin", "FEXServer")
|
||||
thunks_db = os.path.join(prefix, "share", "fex-emu", "ThunksDB.json")
|
||||
return {
|
||||
"bin": binary,
|
||||
"server": server if os.access(server, os.X_OK) else shutil.which("FEXServer"),
|
||||
"portable": portable,
|
||||
"host_thunks": first_dir(prefix, ("lib/aarch64-linux-gnu/fex-emu/HostThunks", "lib/fex-emu/HostThunks", "lib64/fex-emu/HostThunks")),
|
||||
"guest_thunks": first_dir(prefix, ("share/fex-emu/GuestThunks",)),
|
||||
"thunks_db": thunks_db if os.path.isfile(thunks_db) else None,
|
||||
}
|
||||
return None
|
||||
|
||||
|
||||
def platform_version(path):
|
||||
return tuple(int(part) for part in re.findall(r"\d+", os.path.basename(path)))
|
||||
|
||||
|
||||
def runtime_platform():
|
||||
runtime = app_dir(SNIPER_APPID)
|
||||
if not runtime:
|
||||
return None
|
||||
try:
|
||||
entries = os.listdir(runtime)
|
||||
except OSError:
|
||||
return None
|
||||
platforms = [os.path.join(runtime, entry) for entry in entries if entry.startswith("sniper_platform_")]
|
||||
platforms = [path for path in platforms if os.path.isdir(os.path.join(path, "files"))
|
||||
and os.path.isfile(os.path.join(path, "usr-mtree.txt.gz"))]
|
||||
return max(platforms, key=platform_version, default=None)
|
||||
|
||||
|
||||
def unescape(raw):
|
||||
return ESCAPE.sub(lambda match: bytes([int(match.group(1), 8)]), raw)
|
||||
|
||||
|
||||
def in_root(root, link, target):
|
||||
if not target.startswith(b"/"):
|
||||
return target
|
||||
relative = target.lstrip(b"/")
|
||||
if relative == b"usr" or relative.startswith(b"usr/"):
|
||||
relative = relative[4:]
|
||||
return os.path.relpath(os.path.join(root, relative), os.path.dirname(link))
|
||||
|
||||
|
||||
def materialize(platform):
|
||||
mtree = os.path.join(platform, "usr-mtree.txt.gz")
|
||||
info = os.stat(mtree)
|
||||
stamp = "%d %d %d\n" % (LAYOUT, info.st_size, info.st_mtime_ns)
|
||||
root = os.fsencode(os.path.join(platform, "files"))
|
||||
marker = os.path.join(os.fsdecode(root), MARKER)
|
||||
if read_text(marker) == stamp:
|
||||
return False
|
||||
links = []
|
||||
with gzip.open(mtree, "rb") as source:
|
||||
for line in source:
|
||||
parts = line.split()
|
||||
if not parts or parts[0].startswith(b"#"):
|
||||
continue
|
||||
fields = dict(part.split(b"=", 1) for part in parts[1:] if b"=" in part)
|
||||
relative = os.path.normpath(unescape(parts[0]))
|
||||
if os.path.isabs(relative) or relative == b".." or relative.startswith(b"../"):
|
||||
continue
|
||||
dest = os.path.join(root, relative)
|
||||
kind = fields.get(b"type")
|
||||
if kind == b"dir":
|
||||
os.makedirs(dest, exist_ok=True)
|
||||
elif kind == b"file" and b"contents" in fields:
|
||||
blob = os.path.join(root, os.path.normpath(unescape(fields[b"contents"])))
|
||||
links.append((dest, os.path.relpath(blob, os.path.dirname(dest))))
|
||||
elif kind == b"link" and b"link" in fields:
|
||||
links.append((dest, in_root(root, dest, unescape(fields[b"link"]))))
|
||||
for dest, target in links:
|
||||
if os.path.islink(dest):
|
||||
if os.readlink(dest) == target:
|
||||
continue
|
||||
os.unlink(dest)
|
||||
elif os.path.lexists(dest):
|
||||
continue
|
||||
os.makedirs(os.path.dirname(dest), exist_ok=True)
|
||||
os.symlink(target, dest)
|
||||
usr = os.path.join(root, b"usr")
|
||||
if not os.path.lexists(usr):
|
||||
os.symlink(b".", usr)
|
||||
write_if_changed(marker, stamp)
|
||||
return True
|
||||
|
||||
|
||||
def host_preloads():
|
||||
listed = read_text(HOST_PRELOAD) or ""
|
||||
return [name for name in PRELOAD_NAMES if name in listed]
|
||||
|
||||
|
||||
def install_preloads(root):
|
||||
shipped = set()
|
||||
for arch, libdir in GUEST_LIBDIRS:
|
||||
for name in PRELOAD_NAMES:
|
||||
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):
|
||||
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]
|
||||
write_if_changed(os.path.join(root, "etc", "ld.so.preload"), "".join("/usr/$LIB/droiddeck/%s\n" % name for name in wanted))
|
||||
|
||||
|
||||
def write_config(fex, root):
|
||||
config = {"Config": {"RootFS": root}}
|
||||
if fex["host_thunks"] and fex["guest_thunks"] and fex["thunks_db"]:
|
||||
config["Config"]["ThunkHostLibs"] = fex["host_thunks"]
|
||||
config["Config"]["ThunkGuestLibs"] = fex["guest_thunks"]
|
||||
config["ThunksDB"] = dict(THUNKS)
|
||||
write_if_changed(os.path.join(CONFIG_DIR, "ThunksConfig.json"), json.dumps({"ThunksDB": dict(THUNKS)}, indent=2) + "\n")
|
||||
write_if_changed(os.path.join(CONFIG_DIR, "Config.json"), json.dumps(config, indent=2) + "\n")
|
||||
|
||||
|
||||
def link_steam_sdk():
|
||||
for sdk, candidates in (("sdk64", ("linux64", "ubuntu12_64")), ("sdk32", ("linux32", "ubuntu12_32"))):
|
||||
link = os.path.join(HOME, ".steam", sdk)
|
||||
if os.path.lexists(link):
|
||||
continue
|
||||
want = "x86_64" if sdk == "sdk64" else "i386"
|
||||
for candidate in candidates:
|
||||
directory = os.path.join(STEAM_ROOT, candidate)
|
||||
if elf_arch(os.path.join(directory, "steamclient.so")) == want:
|
||||
os.makedirs(os.path.dirname(link), exist_ok=True)
|
||||
os.symlink(directory, link)
|
||||
break
|
||||
|
||||
|
||||
def steam_running():
|
||||
for pid in os.listdir("/proc"):
|
||||
if not pid.isdigit():
|
||||
continue
|
||||
try:
|
||||
with open("/proc/%s/cmdline" % pid, "rb") as f:
|
||||
first = f.read().split(b"\0", 1)[0]
|
||||
except OSError:
|
||||
continue
|
||||
if first.endswith(b"steamrtarm64/steam"):
|
||||
return True
|
||||
return False
|
||||
|
||||
|
||||
def request_install():
|
||||
os.makedirs(os.path.dirname(WANTED), exist_ok=True)
|
||||
write_if_changed(WANTED, "1\n")
|
||||
if not steam_running():
|
||||
return []
|
||||
try:
|
||||
compat = runpy.run_path(os.path.join(BIN_DIR, "steam-compatibility"))
|
||||
return compat["request_fex"](STEAM_ROOT, set())
|
||||
except Exception as error:
|
||||
say("could not ask the client to install FEX (%s)" % error)
|
||||
return []
|
||||
|
||||
|
||||
def describe(fex, platform):
|
||||
return {
|
||||
"fex": fex["bin"] if fex else None,
|
||||
"server": fex["server"] if fex else None,
|
||||
"thunks": bool(fex and fex["host_thunks"] and fex["guest_thunks"] and fex["thunks_db"]),
|
||||
"runtime": platform,
|
||||
"steamclient64": os.path.realpath(os.path.join(HOME, ".steam", "sdk64", "steamclient.so"))
|
||||
if elf_arch(os.path.join(HOME, ".steam", "sdk64", "steamclient.so")) == "x86_64" else None,
|
||||
"ready": bool(fex and fex["server"] and platform),
|
||||
}
|
||||
|
||||
|
||||
def prepare():
|
||||
with locked():
|
||||
fex = fex_install()
|
||||
platform = runtime_platform()
|
||||
status = describe(fex, platform)
|
||||
if not status["ready"]:
|
||||
missing = []
|
||||
tool = app_dir(FEX_APPID)
|
||||
if not fex and tool:
|
||||
say("FEX is installed at %s but holds no FEX or FEXInterpreter in usr/bin, bin or files; it has: %s"
|
||||
% (tool, ", ".join(sorted(os.listdir(tool))[:20])))
|
||||
if not fex:
|
||||
missing.append("FEX (Steam app %s)" % FEX_APPID)
|
||||
elif not fex["server"]:
|
||||
missing.append("FEXServer beside %s" % fex["bin"])
|
||||
if not platform:
|
||||
missing.append("Steam Linux Runtime 3.0 (sniper, Steam app %s)" % SNIPER_APPID)
|
||||
requested = request_install()
|
||||
say("x86 Linux programs need %s; %s" % (" and ".join(missing),
|
||||
"the Steam client was asked to install it" if requested else "open Steam once and it is installed for you"))
|
||||
write_if_changed(STATUS_FILE, json.dumps(status, indent=2) + "\n")
|
||||
return None
|
||||
root = os.path.join(platform, "files")
|
||||
if materialize(platform):
|
||||
say("prepared %s as the x86 runtime" % os.path.basename(platform))
|
||||
install_preloads(root)
|
||||
write_config(fex, root)
|
||||
fex["rootfs"] = root
|
||||
try:
|
||||
link_steam_sdk()
|
||||
except OSError:
|
||||
pass
|
||||
status = describe(fex, platform)
|
||||
write_if_changed(STATUS_FILE, json.dumps(status, indent=2) + "\n")
|
||||
with contextlib.suppress(OSError):
|
||||
os.unlink(WANTED)
|
||||
return fex
|
||||
|
||||
|
||||
def elf_arch(path):
|
||||
try:
|
||||
with open(path, "rb") as f:
|
||||
head = f.read(20)
|
||||
except OSError:
|
||||
return None
|
||||
if len(head) < 20 or head[:4] != b"\x7fELF":
|
||||
return None
|
||||
machine = struct.unpack_from("<H" if head[5] == 1 else ">H", head, 18)[0]
|
||||
return X86.get(machine) or ARM.get(machine) or "other"
|
||||
|
||||
|
||||
def scan(folder):
|
||||
counts = {"x86": 0, "arm": 0}
|
||||
seen = 0
|
||||
base = folder.rstrip("/").count("/")
|
||||
for directory, dirs, files in os.walk(folder):
|
||||
if directory.count("/") - base >= SCAN_DEPTH:
|
||||
dirs[:] = []
|
||||
for name in files:
|
||||
seen += 1
|
||||
if seen > SCAN_LIMIT:
|
||||
return counts
|
||||
arch = elf_arch(os.path.join(directory, name))
|
||||
if arch in X86.values():
|
||||
counts["x86"] += 1
|
||||
elif arch in ARM.values():
|
||||
counts["arm"] += 1
|
||||
return counts
|
||||
|
||||
|
||||
def needs_fex(path):
|
||||
arch = elf_arch(path)
|
||||
if arch is not None:
|
||||
return arch in X86.values()
|
||||
folder = path if os.path.isdir(path) else os.path.dirname(os.path.abspath(path))
|
||||
counts = scan(folder)
|
||||
return counts["x86"] > 0 and counts["arm"] == 0
|
||||
|
||||
|
||||
def is_arm(path):
|
||||
return elf_arch(path) in ARM.values()
|
||||
|
||||
|
||||
def split_paths(value):
|
||||
return [part for part in re.split(r"[:\s]+", value or "") if part]
|
||||
|
||||
|
||||
def guest_environment(fex, env):
|
||||
result = dict(env)
|
||||
for directory in (CONFIG_DIR, DATA_DIR, 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_CACHE_LOCATION"] = CACHE_DIR + "/"
|
||||
result.setdefault("FEX_SILENTLOG", "0")
|
||||
result.setdefault("FEX_OUTPUTLOG", "stderr")
|
||||
if fex["portable"]:
|
||||
result["FEX_PORTABLE"] = "1"
|
||||
else:
|
||||
result.pop("FEX_PORTABLE", None)
|
||||
for name in ("FEX_ROOTFS", "FEX_THUNKHOSTLIBS", "FEX_THUNKGUESTLIBS"):
|
||||
if name in result and not os.path.exists(result[name]):
|
||||
result.pop(name)
|
||||
if fex.get("rootfs"):
|
||||
result["FEX_ROOTFS"] = fex["rootfs"]
|
||||
if fex.get("rootfs") and fex.get("host_thunks") and fex.get("guest_thunks") and fex.get("thunks_db"):
|
||||
result["FEX_THUNKHOSTLIBS"] = fex["host_thunks"]
|
||||
result["FEX_THUNKGUESTLIBS"] = fex["guest_thunks"]
|
||||
result["FEX_THUNKCONFIG"] = os.path.join(CONFIG_DIR, "ThunksConfig.json")
|
||||
preload = [part for part in split_paths(result.get("LD_PRELOAD")) if os.path.exists(part) and not is_arm(part)]
|
||||
library_path = [part for part in (result.get("LD_LIBRARY_PATH") or "").split(":")
|
||||
if part and "steamrtarm64" not in part and "aarch64" not in part]
|
||||
for name, parts in (("LD_PRELOAD", preload), ("LD_LIBRARY_PATH", library_path)):
|
||||
if parts:
|
||||
result[name] = ":".join(parts)
|
||||
else:
|
||||
result.pop(name, None)
|
||||
return result
|
||||
|
||||
|
||||
def version_names(path):
|
||||
try:
|
||||
with open(path, "rb") as f:
|
||||
return set(VERSION_NAME.findall(f.read()))
|
||||
except OSError:
|
||||
return set()
|
||||
|
||||
|
||||
def bundled_libraries(folder):
|
||||
wanted = [name for name, _ in RUNTIME_LIBRARIES]
|
||||
found = {}
|
||||
seen = 0
|
||||
base = folder.rstrip("/").count("/")
|
||||
for directory, dirs, files in os.walk(folder):
|
||||
seen += len(files)
|
||||
if seen > SCAN_LIMIT:
|
||||
break
|
||||
if directory.count("/") - base >= BUNDLE_DEPTH:
|
||||
dirs[:] = []
|
||||
for name in wanted:
|
||||
if name in files and name not in found:
|
||||
found[name] = os.path.join(directory, name)
|
||||
return found
|
||||
|
||||
|
||||
def vulkan_thunk_loads(fex, folder):
|
||||
needed = version_names(os.path.join(fex["guest_thunks"], VULKAN_THUNK))
|
||||
if not needed:
|
||||
return False
|
||||
found = bundled_libraries(folder)
|
||||
for name, prefix in RUNTIME_LIBRARIES:
|
||||
library = found.get(name) or os.path.join(fex["rootfs"], "lib/x86_64-linux-gnu", name)
|
||||
if not {version for version in needed if version.startswith(prefix)} <= version_names(library):
|
||||
return False
|
||||
return True
|
||||
|
||||
|
||||
def resolve(program, env):
|
||||
if "/" in program:
|
||||
return os.path.abspath(program)
|
||||
return shutil.which(program, path=env.get("PATH")) or program
|
||||
|
||||
|
||||
def launch(command, env, mode, decide=None):
|
||||
program = resolve(command[0], env)
|
||||
use = mode == "on" or (mode == "auto" and needs_fex(decide or program))
|
||||
if not use:
|
||||
return os.execvpe(command[0], command, env)
|
||||
fex = prepare()
|
||||
if fex is 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)) \
|
||||
and vulkan_thunk_loads(fex, folder):
|
||||
guest["LD_AUDIT"] = ":".join([THUNK_AUDIT_GUEST] + split_paths(guest.get("LD_AUDIT")))
|
||||
thunks = "on, its own Vulkan loader too"
|
||||
say("running %s with %s (runtime %s, thunks %s)" % (program, fex["bin"], guest.get("FEX_ROOTFS", "none"), thunks))
|
||||
return os.execve(fex["bin"], [fex["bin"], program] + command[1:], guest)
|
||||
|
||||
|
||||
def game_environment(env):
|
||||
try:
|
||||
game_env = runpy.run_path(os.path.join(BIN_DIR, "droiddeck-game-env"))
|
||||
app = game_env["game_id"](env) or env.get("SteamAppId") or env.get("SteamGameId")
|
||||
if not app:
|
||||
return env
|
||||
with open(GAME_ENVIRONMENT, encoding="utf-8") as source:
|
||||
return game_env["apply_config"](env, json.load(source), str(app))
|
||||
except FileNotFoundError:
|
||||
return env
|
||||
except Exception as error:
|
||||
say("game settings were not applied (%s)" % error)
|
||||
return env
|
||||
|
||||
|
||||
def appimage_offset(path):
|
||||
with open(path, "rb") as f:
|
||||
head = f.read(64)
|
||||
if head[:4] != b"\x7fELF":
|
||||
raise ValueError("not an ELF file")
|
||||
order = "<" if head[5] == 1 else ">"
|
||||
if head[4] == 2:
|
||||
shoff, = struct.unpack_from(order + "Q", head, 0x28)
|
||||
shentsize, shnum = struct.unpack_from(order + "HH", head, 0x3A)
|
||||
else:
|
||||
shoff, = struct.unpack_from(order + "I", head, 0x20)
|
||||
shentsize, shnum = struct.unpack_from(order + "HH", head, 0x2E)
|
||||
return shoff + shentsize * shnum
|
||||
|
||||
|
||||
def clear_extracted():
|
||||
for stale in ("squashfs-root", "AppDir"):
|
||||
if os.path.islink(stale):
|
||||
os.unlink(stale)
|
||||
else:
|
||||
shutil.rmtree(stale, ignore_errors=True)
|
||||
|
||||
|
||||
def extracted():
|
||||
if os.path.isdir("AppDir") and not os.path.lexists("squashfs-root"):
|
||||
os.symlink("AppDir", "squashfs-root")
|
||||
return os.path.isdir("squashfs-root")
|
||||
|
||||
|
||||
def want_fex():
|
||||
with locked():
|
||||
status = describe(fex_install(), runtime_platform())
|
||||
if not status["ready"]:
|
||||
request_install()
|
||||
write_if_changed(STATUS_FILE, json.dumps(status, indent=2) + "\n")
|
||||
|
||||
|
||||
def extract(image):
|
||||
image = os.path.abspath(image)
|
||||
clear_extracted()
|
||||
x86 = elf_arch(image) in X86.values()
|
||||
if os.access(URUNTIME, os.X_OK):
|
||||
status = subprocess.call([URUNTIME, "--appimage-extract"], stdout=subprocess.DEVNULL,
|
||||
env=dict(os.environ, TARGET_APPIMAGE=image))
|
||||
if status == 0 and extracted():
|
||||
if x86:
|
||||
want_fex()
|
||||
return 0
|
||||
say("uruntime could not extract it (status %d)" % status)
|
||||
clear_extracted()
|
||||
fex = prepare() if x86 else None
|
||||
if fex is not None:
|
||||
status = subprocess.call([fex["bin"], image, "--appimage-extract"], stdout=subprocess.DEVNULL,
|
||||
env=guest_environment(fex, dict(os.environ)))
|
||||
if status == 0 and extracted():
|
||||
return 0
|
||||
say("the image's own runtime could not extract it under FEX (status %d)" % status)
|
||||
unsquashfs = shutil.which("unsquashfs")
|
||||
if unsquashfs:
|
||||
clear_extracted()
|
||||
status = subprocess.call([unsquashfs, "-q", "-n", "-o", str(appimage_offset(image)), "-d", "squashfs-root", image],
|
||||
stdout=subprocess.DEVNULL)
|
||||
if status == 0:
|
||||
if x86:
|
||||
want_fex()
|
||||
return 0
|
||||
say("unsquashfs could not extract it (status %d)" % status)
|
||||
elif fex is None:
|
||||
say("this AppImage could not be unpacked here: no AppImage runtime for ARM64, no FEX yet and no unsquashfs")
|
||||
return 1
|
||||
|
||||
|
||||
def parse_run(args):
|
||||
mode, decide = os.environ.get("DROIDDECK_FEX", "auto"), None
|
||||
while args and args[0].startswith("--"):
|
||||
option = args.pop(0)
|
||||
if option == "--":
|
||||
break
|
||||
if option in ("--mode", "--for") and args:
|
||||
value = args.pop(0)
|
||||
if option == "--mode":
|
||||
mode = value
|
||||
else:
|
||||
decide = value
|
||||
else:
|
||||
raise ValueError("unknown option %s" % option)
|
||||
if mode not in MODES:
|
||||
raise ValueError("--mode takes %s" % ", ".join(MODES))
|
||||
return mode, decide, args
|
||||
|
||||
|
||||
def main(argv):
|
||||
if not argv:
|
||||
say("usage: droiddeck-fex steam VERB CMD... | run [--mode auto|on|off] [--for PATH] [--] CMD... | needs PATH | extract IMAGE | prepare | status")
|
||||
return 2
|
||||
action, args = argv[0], list(argv[1:])
|
||||
if action == "steam":
|
||||
if not args:
|
||||
return 2
|
||||
verb, command = args[0], args[1:]
|
||||
if verb not in STEAM_VERBS:
|
||||
return 0
|
||||
if not command:
|
||||
return 2
|
||||
return launch(command, game_environment(dict(os.environ)), os.environ.get("DROIDDECK_FEX", "auto"))
|
||||
if action == "run":
|
||||
try:
|
||||
mode, decide, command = parse_run(args)
|
||||
except ValueError as error:
|
||||
say(str(error))
|
||||
return 2
|
||||
if not command:
|
||||
return 2
|
||||
return launch(command, dict(os.environ), mode, decide)
|
||||
if action == "needs":
|
||||
if len(args) != 1:
|
||||
return 2
|
||||
needed = needs_fex(args[0])
|
||||
print("fex" if needed else "native")
|
||||
return 0 if needed else 1
|
||||
if action == "extract":
|
||||
if len(args) != 1:
|
||||
return 2
|
||||
return extract(args[0])
|
||||
if action == "prepare":
|
||||
return 0 if prepare() else 1
|
||||
if action == "status":
|
||||
with locked():
|
||||
status = describe(fex_install(), runtime_platform())
|
||||
write_if_changed(STATUS_FILE, json.dumps(status, indent=2) + "\n")
|
||||
print(json.dumps(status, indent=2))
|
||||
return 0 if status["ready"] else 1
|
||||
say("unknown action %s" % action)
|
||||
return 2
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
sys.exit(main(sys.argv[1:]))
|
||||
+7
-7
@@ -3,10 +3,10 @@
|
||||
# reaches the front end as numbers rather than a terminal's redrawn bar. Per-user installation,
|
||||
# Flathub as the remote, this device's architecture.
|
||||
#
|
||||
# bannerlator-flatpak install <app-id> the app and whatever runtimes it needs
|
||||
# bannerlator-flatpak uninstall <app-id> the app, then runtimes nothing uses any more
|
||||
# bannerlator-flatpak update [<app-id>] one app, or everything with an update
|
||||
# bannerlator-flatpak updates what has one (a "updates" line)
|
||||
# droiddeck-flatpak install <app-id> the app and whatever runtimes it needs
|
||||
# droiddeck-flatpak uninstall <app-id> the app, then runtimes nothing uses any more
|
||||
# droiddeck-flatpak update [<app-id>] one app, or everything with an update
|
||||
# droiddeck-flatpak updates what has one (a "updates" line)
|
||||
#
|
||||
# Lines: {"e":"op","i":1,"n":3,"kind":"install","ref":"..."} as each step starts,
|
||||
# {"e":"progress","i":1,"n":3,"percent":45,"status":"..."} while it runs,
|
||||
@@ -15,7 +15,7 @@ import json
|
||||
import os
|
||||
import sys
|
||||
|
||||
os.environ.setdefault("FLATPAK_BWRAP", "/usr/local/bin/bannerlator-bwrap")
|
||||
os.environ.setdefault("FLATPAK_BWRAP", "/usr/local/bin/droiddeck-bwrap")
|
||||
|
||||
import gi # noqa: E402
|
||||
|
||||
@@ -216,7 +216,7 @@ def updates():
|
||||
|
||||
def main():
|
||||
if len(sys.argv) < 2:
|
||||
sys.stderr.write(__doc__ or "usage: bannerlator-flatpak install|uninstall|update|updates [app-id]\n")
|
||||
sys.stderr.write(__doc__ or "usage: droiddeck-flatpak install|uninstall|update|updates [app-id]\n")
|
||||
return 2
|
||||
cmd, args = sys.argv[1], sys.argv[2:]
|
||||
if cmd in ("install", "update"):
|
||||
@@ -229,7 +229,7 @@ def main():
|
||||
return update(args[0] if args else None)
|
||||
if cmd == "updates":
|
||||
return updates()
|
||||
sys.stderr.write("usage: bannerlator-flatpak install|uninstall|update|updates [app-id]\n")
|
||||
sys.stderr.write("usage: droiddeck-flatpak install|uninstall|update|updates [app-id]\n")
|
||||
return 2
|
||||
|
||||
|
||||
+2
-2
@@ -1,8 +1,8 @@
|
||||
#!/bin/bash
|
||||
# A Flatpak app from the front end, full screen under gamescope like an emulator:
|
||||
# bannerlator-flatpak-run <app-id> [args...]
|
||||
# droiddeck-flatpak-run <app-id> [args...]
|
||||
set -u
|
||||
export FLATPAK_BWRAP=/usr/local/bin/bannerlator-bwrap
|
||||
export FLATPAK_BWRAP=/usr/local/bin/droiddeck-bwrap
|
||||
case ":${XDG_DATA_DIRS:-}:" in
|
||||
*"/flatpak/exports/share:"*) ;;
|
||||
*) export XDG_DATA_DIRS=$HOME/.local/share/flatpak/exports/share:${XDG_DATA_DIRS:-/usr/local/share:/usr/share} ;;
|
||||
+3
-3
@@ -9,7 +9,7 @@
|
||||
# few packages Flatpak needs on top of this image, verifying each against the Arch Linux ARM
|
||||
# keyring, and they are unpacked here without hooks or scripts, like the desktop package itself.
|
||||
#
|
||||
# bannerlator-flatpak-setup install or repair; prints "== STEP ..." milestones
|
||||
# droiddeck-flatpak-setup install or repair; prints "== STEP ..." milestones
|
||||
set -u
|
||||
export LANG=C.UTF-8
|
||||
step() { echo "== STEP $*"; }
|
||||
@@ -17,7 +17,7 @@ fail() { echo "== FAIL $*"; exit 1; }
|
||||
|
||||
# Flatpak, the libraries it and appstream add to this image, and the D-Bus proxy flatpak run puts
|
||||
# between an app and the session bus. bubblewrap is not among them: Android gives an app no user
|
||||
# namespaces, and bannerlator-bwrap stands in for it (FLATPAK_BWRAP).
|
||||
# namespaces, and droiddeck-bwrap stands in for it (FLATPAK_BWRAP).
|
||||
PACKAGES="flatpak ostree appstream libxmlb libmalcontent libfyaml accountsservice composefs xdg-dbus-proxy"
|
||||
# Libraries Flatpak and the store's helper also need, which the Desktop package brings but a
|
||||
# runtime without it may lack: each is fetched only when its file is not already there.
|
||||
@@ -97,7 +97,7 @@ python3 -c 'import gi; gi.require_version("Flatpak", "1.0"); from gi.repository
|
||||
|| fail "the store helper cannot load libflatpak from Python"
|
||||
|
||||
step "Adding Flathub"
|
||||
export FLATPAK_BWRAP=/usr/local/bin/bannerlator-bwrap
|
||||
export FLATPAK_BWRAP=/usr/local/bin/droiddeck-bwrap
|
||||
# Flathub's descriptor - its URL and the key its commits are signed with - is carried here rather
|
||||
# than fetched: adding the remote then needs no network, and a descriptor that did not arrive
|
||||
# whole cannot be what failed. Flathub's own copy: https://dl.flathub.org/repo/flathub.flatpakrepo
|
||||
+78
-9
@@ -2,9 +2,13 @@
|
||||
import json
|
||||
import os
|
||||
import re
|
||||
import runpy
|
||||
import sys
|
||||
from pathlib import Path
|
||||
|
||||
SYNC_KEYS = ("BL_SYNC_FALLBACK", "BL_FSYNC_FIRST", "BL_SYNC_MIN_NOFILE", "PROTON_NO_ESYNC", "PROTON_NO_FSYNC", "PROTON_NO_NTSYNC", "WINEESYNC")
|
||||
PACK_KEYS = ("WINESERVER", "BL_SYNC_PACK", "WINEESYNC", "PROTON_NO_ESYNC", "PROTON_NO_FSYNC")
|
||||
|
||||
|
||||
def game_id(env):
|
||||
prefix = env.get("STEAM_COMPAT_DATA_PATH", "").rstrip("/")
|
||||
@@ -144,26 +148,91 @@ def apply_config(env, config, app_id, fixes=None):
|
||||
return result
|
||||
|
||||
|
||||
def sync_config(config, app_id):
|
||||
games = config.get("games", {})
|
||||
return {
|
||||
"version": config.get("version"),
|
||||
"shared": {name: value for name, value in config.get("shared", {}).items() if name in SYNC_KEYS},
|
||||
"games": {app_id: {name: value for name, value in games.get(app_id, {}).items() if name in SYNC_KEYS}},
|
||||
}
|
||||
|
||||
|
||||
def load_sync():
|
||||
try:
|
||||
return runpy.run_path(str(Path(__file__).resolve().parent / "droiddeck-esync"))
|
||||
except Exception as error:
|
||||
print("droiddeck-game-env: sync selection failed (%s); stock launch" % error, file=sys.stderr)
|
||||
return None
|
||||
|
||||
|
||||
def select_sync(command, env, sync=None):
|
||||
try:
|
||||
sync = sync if sync is not None else load_sync()
|
||||
if sync is None:
|
||||
return command, env
|
||||
chosen, chosen_env = sync["select"](command, env)
|
||||
if chosen and all(isinstance(value, str) for value in chosen) and isinstance(chosen_env, dict):
|
||||
return list(chosen), dict(chosen_env)
|
||||
except Exception as error:
|
||||
print("droiddeck-game-env: sync selection failed (%s); stock launch" % error, file=sys.stderr)
|
||||
return command, env
|
||||
|
||||
|
||||
def record_stock(sync, command, env):
|
||||
try:
|
||||
if sync is not None and "record" in sync:
|
||||
sync["record"](command, env)
|
||||
except Exception as error:
|
||||
print("droiddeck-game-env: stock launch not recorded (%s)" % error, file=sys.stderr)
|
||||
|
||||
|
||||
def without_pack(chosen_env, env):
|
||||
result = dict(chosen_env)
|
||||
for name in PACK_KEYS:
|
||||
if name in env:
|
||||
result[name] = env[name]
|
||||
else:
|
||||
result.pop(name, None)
|
||||
return result
|
||||
|
||||
|
||||
def main():
|
||||
command = sys.argv[1:]
|
||||
if not command:
|
||||
return 2
|
||||
env = os.environ.copy()
|
||||
app_id = game_id(env)
|
||||
if len(command) > 1 and command[1] == "waitforexitandrun" and app_id:
|
||||
fixes, extra, notes = engine_fixes(command[2], command[3:]) if len(command) > 2 else ({}, [], [])
|
||||
for note in notes:
|
||||
print("bannerlator-game-env: " + note, file=sys.stderr)
|
||||
command += extra
|
||||
if app_id:
|
||||
waiting = len(command) > 1 and command[1] == "waitforexitandrun"
|
||||
fixes = {}
|
||||
if waiting:
|
||||
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)
|
||||
command += extra
|
||||
path = Path.home() / ".config/droiddeck/game-environment.json"
|
||||
try:
|
||||
with path.open(encoding="utf-8") as source:
|
||||
env = apply_config(env, json.load(source), app_id, fixes)
|
||||
config = json.load(source)
|
||||
if waiting:
|
||||
env = apply_config(env, config, app_id, fixes)
|
||||
else:
|
||||
env = apply_config(env, sync_config(config, app_id), app_id)
|
||||
except FileNotFoundError:
|
||||
env = apply_config(env, {"version": 1}, app_id, fixes)
|
||||
if waiting:
|
||||
env = apply_config(env, {"version": 1}, app_id, fixes)
|
||||
except (OSError, ValueError, TypeError, AttributeError):
|
||||
print("bannerlator-game-env: invalid configuration; using inherited environment", file=sys.stderr)
|
||||
os.execvpe(command[0], command, env)
|
||||
print("droiddeck-game-env: invalid configuration; using inherited environment", file=sys.stderr)
|
||||
sync = load_sync()
|
||||
launch, launch_env = select_sync(command, env, sync)
|
||||
if launch[0] != command[0]:
|
||||
try:
|
||||
os.execvpe(launch[0], launch, launch_env)
|
||||
except OSError as error:
|
||||
print("droiddeck-game-env: %s could not start (%s); stock launch" % (launch[0], error), file=sys.stderr)
|
||||
launch, launch_env = command, without_pack(launch_env, env)
|
||||
record_stock(sync, launch, launch_env)
|
||||
os.execvpe(launch[0], launch, launch_env)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
+1
-1
@@ -126,7 +126,7 @@ class LoginManager:
|
||||
def main():
|
||||
directory = os.environ.get("BL_LAUNCH_DIR")
|
||||
if not directory or not Path(directory).is_dir():
|
||||
sys.exit("bannerlator-login1: no DroidDeck session directory")
|
||||
sys.exit("droiddeck-login1: no DroidDeck session directory")
|
||||
ready = Path(directory) / "steam-sleep-ready"
|
||||
ready.unlink(missing_ok=True)
|
||||
loop = GLib.MainLoop()
|
||||
+2
-2
@@ -27,8 +27,8 @@ IP6 = ROOT + "/IP6Config/1"
|
||||
AP = ROOT + "/AccessPoint/1"
|
||||
PROFILE = SETTINGS + "/1"
|
||||
UUID = "b1d0c8e4-57f0-4c0e-9d60-77696e6e6174"
|
||||
SNAPSHOT = Path("/etc/bannerlator-network.json")
|
||||
SCAN_REQUEST = Path("/etc/bannerlator-wifi-scan-request")
|
||||
SNAPSHOT = Path("/etc/droiddeck-network.json")
|
||||
SCAN_REQUEST = Path("/etc/droiddeck-wifi-scan-request")
|
||||
OBJECT_MANAGER = "org.freedesktop.DBus.ObjectManager"
|
||||
PROPERTIES = "org.freedesktop.DBus.Properties"
|
||||
|
||||
+22
-22
@@ -17,7 +17,7 @@ def seed(path, text, what, done="Player 1 on the controller"):
|
||||
with open(path + ".tmp", "w", encoding="utf-8") as f:
|
||||
f.write(text)
|
||||
os.replace(path + ".tmp", path)
|
||||
print(f"bannerlator-pad-defaults: {what}: {done} ({path})")
|
||||
print(f"droiddeck-pad-defaults: {what}: {done} ({path})")
|
||||
return True
|
||||
|
||||
|
||||
@@ -97,7 +97,7 @@ def rpcs3_shader_mode():
|
||||
with open(cfg + ".tmp", "w", encoding="utf-8") as f:
|
||||
f.write(text)
|
||||
os.replace(cfg + ".tmp", cfg)
|
||||
print(f"bannerlator-pad-defaults: RPCS3: shader mode {RPCS3_RECOMPILER} ({cfg})")
|
||||
print(f"droiddeck-pad-defaults: RPCS3: shader mode {RPCS3_RECOMPILER} ({cfg})")
|
||||
open(marker, "w").close()
|
||||
|
||||
|
||||
@@ -144,7 +144,7 @@ def patch_ini_section(path, section, body, what, needle="SDL-", require=None, do
|
||||
with open(path + ".tmp", "w", encoding="utf-8") as f:
|
||||
f.write("\n".join(lines) + "\n")
|
||||
os.replace(path + ".tmp", path)
|
||||
print(f"bannerlator-pad-defaults: {what}: {done} ({path})")
|
||||
print(f"droiddeck-pad-defaults: {what}: {done} ({path})")
|
||||
|
||||
|
||||
# DuckStation: SDL-<n>/<name>, axes signed (src/util/sdl_input_source.cpp); Pad1 keys from
|
||||
@@ -285,12 +285,12 @@ def duckstation():
|
||||
# One set up by an earlier build still has its first-time setup pending, in the way of a game.
|
||||
if ini_get(ini, "Main", "SetupWizardIncomplete") == "true":
|
||||
ini_set(ini, "Main", "SetupWizardIncomplete", "false")
|
||||
print("bannerlator-pad-defaults: DuckStation: first-time setup already done here")
|
||||
print("droiddeck-pad-defaults: DuckStation: first-time setup already done here")
|
||||
# Keeping the screen awake goes through org.freedesktop.ScreenSaver, which nothing in the session
|
||||
# provides (Android decides when the screen sleeps): DuckStation only warns it failed, every game.
|
||||
if (ini_get(ini, "Main", "InhibitScreensaver") or "true") == "true":
|
||||
ini_set(ini, "Main", "InhibitScreensaver", "false")
|
||||
print("bannerlator-pad-defaults: DuckStation: no screensaver inhibit (no such service here)")
|
||||
print("droiddeck-pad-defaults: DuckStation: no screensaver inhibit (no such service here)")
|
||||
# Once, for a DuckStation set up before this: its own empty BIOS folder moves to the ROMs folder,
|
||||
# and Automatic becomes Vulkan. A later choice in DuckStation's settings is kept.
|
||||
marker = os.path.join(os.path.dirname(ini), ".droiddeck-setup")
|
||||
@@ -300,10 +300,10 @@ def duckstation():
|
||||
own = current if os.path.isabs(current) else os.path.join(os.path.dirname(ini), current)
|
||||
if not (os.path.isdir(own) and os.listdir(own)):
|
||||
ini_set(ini, "BIOS", "SearchDirectory", bios_folder(ps1))
|
||||
print(f"bannerlator-pad-defaults: DuckStation: BIOS from {bios_folder(ps1)}")
|
||||
print(f"droiddeck-pad-defaults: DuckStation: BIOS from {bios_folder(ps1)}")
|
||||
if (ini_get(ini, "GPU", "Renderer") or "Automatic") == "Automatic":
|
||||
ini_set(ini, "GPU", "Renderer", "Vulkan")
|
||||
print("bannerlator-pad-defaults: DuckStation: renderer Vulkan")
|
||||
print("droiddeck-pad-defaults: DuckStation: renderer Vulkan")
|
||||
open(marker, "w").close()
|
||||
|
||||
|
||||
@@ -451,7 +451,7 @@ def armsx2():
|
||||
src = os.path.join(old, sub)
|
||||
if os.path.isdir(src):
|
||||
shutil.copytree(src, os.path.join(root, sub), dirs_exist_ok=True)
|
||||
print(f"bannerlator-pad-defaults: ARMSX2: settings and memory cards copied from PCSX2 ({root})")
|
||||
print(f"droiddeck-pad-defaults: ARMSX2: settings and memory cards copied from PCSX2 ({root})")
|
||||
elif not os.path.isfile(ini):
|
||||
# A new player: everything ARMSX2's first-time setup asks is answered here - the BIOS
|
||||
# folder in the ROMs folder, the ps2 folder as its game list, the controller on Player 1 -
|
||||
@@ -482,7 +482,7 @@ def armsx2():
|
||||
require="SettingsVersion", done="games listed from the ROMs folder")
|
||||
if ini_get(ini, "UI", "SetupWizardIncomplete") == "true":
|
||||
ini_set(ini, "UI", "SetupWizardIncomplete", "false")
|
||||
print("bannerlator-pad-defaults: ARMSX2: first-time setup already done here")
|
||||
print("droiddeck-pad-defaults: ARMSX2: first-time setup already done here")
|
||||
armsx2_bios(ini)
|
||||
|
||||
|
||||
@@ -507,7 +507,7 @@ def armsx2_bios(ini):
|
||||
us = [f for f in dumps if any(t in f.lower() for t in ("usa", "(us)", "(us,", "ntsc-u"))]
|
||||
pick = (us or dumps)[0]
|
||||
ini_set(ini, "Filenames", "BIOS", pick)
|
||||
print(f"bannerlator-pad-defaults: ARMSX2: BIOS {pick}")
|
||||
print(f"droiddeck-pad-defaults: ARMSX2: BIOS {pick}")
|
||||
|
||||
|
||||
# Dolphin (PC) has no controller menu, so the guide button is its Toggle Fullscreen hotkey: out of full
|
||||
@@ -596,7 +596,7 @@ def dolphin_data():
|
||||
stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, timeout=600)
|
||||
src = os.path.join(work, "squashfs-root/usr/share/dolphin-emu")
|
||||
if not os.path.isfile(os.path.join(src, "Sys/GC/font_western.bin")):
|
||||
print("bannerlator-pad-defaults: Dolphin: could not unpack its data from the AppImage")
|
||||
print("droiddeck-pad-defaults: Dolphin: could not unpack its data from the AppImage")
|
||||
return
|
||||
new = DOLPHIN_DATA + ".new"
|
||||
shutil.rmtree(new, ignore_errors=True)
|
||||
@@ -605,9 +605,9 @@ def dolphin_data():
|
||||
f.write(stamp)
|
||||
shutil.rmtree(DOLPHIN_DATA, ignore_errors=True)
|
||||
os.rename(new, DOLPHIN_DATA)
|
||||
print("bannerlator-pad-defaults: Dolphin: its data (fonts, per-game fixes) in " + DOLPHIN_DATA)
|
||||
print("droiddeck-pad-defaults: Dolphin: its data (fonts, per-game fixes) in " + DOLPHIN_DATA)
|
||||
except (OSError, subprocess.SubprocessError) as e:
|
||||
print("bannerlator-pad-defaults: Dolphin: unpacking its data failed: %s" % e)
|
||||
print("droiddeck-pad-defaults: Dolphin: unpacking its data failed: %s" % e)
|
||||
finally:
|
||||
shutil.rmtree(work, ignore_errors=True)
|
||||
|
||||
@@ -622,7 +622,7 @@ def dolphin():
|
||||
wii_pad = os.path.join(d, "WiimoteNew.ini")
|
||||
if ini_get(wii_pad, "Wiimote1", "Buttons/Home") == "`Guide`":
|
||||
ini_set(wii_pad, "Wiimote1", "Buttons/Home", "`Shoulder R`")
|
||||
print("bannerlator-pad-defaults: Dolphin (Wii): Home on the right shoulder button (guide = Dolphin's window)")
|
||||
print("droiddeck-pad-defaults: Dolphin (Wii): Home on the right shoulder button (guide = Dolphin's window)")
|
||||
hotkeys = os.path.join(d, "Hotkeys.ini")
|
||||
if not os.path.isfile(hotkeys):
|
||||
seed(hotkeys, DOLPHIN_HOTKEYS, "Dolphin", "the guide button shows Dolphin's window (Toggle Fullscreen)")
|
||||
@@ -631,7 +631,7 @@ def dolphin():
|
||||
if current is not None and DOLPHIN_GUIDE not in current:
|
||||
ini_set(hotkeys, "Hotkeys", "General/Toggle Fullscreen",
|
||||
(current + " | " if current else "") + DOLPHIN_GUIDE)
|
||||
print("bannerlator-pad-defaults: Dolphin: the guide button shows Dolphin's window (Toggle Fullscreen)")
|
||||
print("droiddeck-pad-defaults: Dolphin: the guide button shows Dolphin's window (Toggle Fullscreen)")
|
||||
# Games from the ROMs folder's gamecube and wii folders, subfolders included; Vulkan; no
|
||||
# NKit warning (it will not let a game start until a box is ticked - games run either way,
|
||||
# the warning is about loading times, netplay and save states); no statistics question.
|
||||
@@ -647,7 +647,7 @@ def dolphin():
|
||||
"[Core]\nGFXBackend = Vulkan\n"
|
||||
"[General]\nISOPaths = 2\nISOPath0 = %s\nISOPath1 = %s\nRecursiveISOPaths = True\n"
|
||||
"[Interface]\nSkipNKitWarning = True\n" % (gc, wii))
|
||||
print("bannerlator-pad-defaults: Dolphin: first-time setup (Vulkan, games from %s and %s)" % (gc, wii))
|
||||
print("droiddeck-pad-defaults: Dolphin: first-time setup (Vulkan, games from %s and %s)" % (gc, wii))
|
||||
return
|
||||
try:
|
||||
count = int(ini_get(ini, "General", "ISOPaths") or "0")
|
||||
@@ -679,7 +679,7 @@ def dolphin():
|
||||
ini_set(ini, "General", "RecursiveISOPaths", "True")
|
||||
changed.append("subfolders")
|
||||
if changed:
|
||||
print("bannerlator-pad-defaults: Dolphin: games from " + ", ".join(changed))
|
||||
print("droiddeck-pad-defaults: Dolphin: games from " + ", ".join(changed))
|
||||
# Once, for a Dolphin set up before this: Vulkan unless it was chosen already, and the NKit box.
|
||||
marker = os.path.join(d, ".droiddeck-setup")
|
||||
if os.path.exists(marker):
|
||||
@@ -691,7 +691,7 @@ def dolphin():
|
||||
ini_set(ini, "Analytics", "Enabled", "False")
|
||||
ini_set(ini, "Analytics", "PermissionAsked", "True")
|
||||
open(marker, "w").close()
|
||||
print("bannerlator-pad-defaults: Dolphin: Vulkan, no NKit warning")
|
||||
print("droiddeck-pad-defaults: Dolphin: Vulkan, no NKit warning")
|
||||
|
||||
|
||||
# Cemu: an SDLController profile for the GamePad. The uuid is "<index>_<SDL GUID>" and SDL's GUID
|
||||
@@ -954,7 +954,7 @@ def melonds():
|
||||
with open(path + ".tmp", "w", encoding="utf-8") as f:
|
||||
f.write("\n".join(lines).rstrip("\n") + "\n")
|
||||
os.replace(path + ".tmp", path)
|
||||
print(f"bannerlator-pad-defaults: melonDS: {'; '.join(done)} ({path})")
|
||||
print(f"droiddeck-pad-defaults: melonDS: {'; '.join(done)} ({path})")
|
||||
|
||||
|
||||
# PPSSPP (SDL): its pad defaults leave the shoulders, the right stick and the triggers unbound on
|
||||
@@ -1041,7 +1041,7 @@ def retroarch():
|
||||
with open(cfg + ".tmp", "w", encoding="utf-8") as f:
|
||||
f.write("\n".join(lines) + "\n")
|
||||
os.replace(cfg + ".tmp", cfg)
|
||||
print(f"bannerlator-pad-defaults: RetroArch: joypad driver udev -> sdl2 ({cfg})")
|
||||
print(f"droiddeck-pad-defaults: RetroArch: joypad driver udev -> sdl2 ({cfg})")
|
||||
|
||||
|
||||
# yuzu and its forks: Player 1 in [Controls] of <name>/qt-config.ini, which each writes at its first
|
||||
@@ -1090,11 +1090,11 @@ def switch_emulators():
|
||||
f.write("\n".join(lines) + "\n")
|
||||
os.replace(cfg + ".tmp", cfg)
|
||||
open(marker, "w").close()
|
||||
print(f"bannerlator-pad-defaults: {name}: Player 1 on the controller ({cfg})")
|
||||
print(f"droiddeck-pad-defaults: {name}: Player 1 on the controller ({cfg})")
|
||||
|
||||
|
||||
for step in (rpcs3, duckstation, pcsx2, armsx2, dolphin, cemu, melonds, ppsspp, retroarch, switch_emulators):
|
||||
try:
|
||||
step()
|
||||
except Exception as e:
|
||||
print(f"bannerlator-pad-defaults: {step.__name__}: {e}")
|
||||
print(f"droiddeck-pad-defaults: {step.__name__}: {e}")
|
||||
+21
-20
@@ -1,12 +1,12 @@
|
||||
#!/usr/bin/python3
|
||||
# Installs a third-party Proton build into the client's compatibilitytools.d, so it appears in the
|
||||
# Compatibility dropdown beside Bannerlator Proton (ARM64) and can be picked per game.
|
||||
# Compatibility dropdown beside our own Proton ARM64 and can be picked per game.
|
||||
#
|
||||
# bannerlator-proton-extra <steam root> ge [--tag GE-Proton11-7]
|
||||
# bannerlator-proton-extra <steam root> cachyos [--tag cachyos-11.0-20260703-slr]
|
||||
# bannerlator-proton-extra <steam root> <url of an aarch64 tarball>
|
||||
# bannerlator-proton-extra <steam root> /path/to/an/aarch64/tarball
|
||||
# bannerlator-proton-extra <steam root> --list what is installed now
|
||||
# droiddeck-proton-extra <steam root> ge [--tag GE-Proton11-7]
|
||||
# droiddeck-proton-extra <steam root> cachyos [--tag cachyos-11.0-20260703-slr]
|
||||
# droiddeck-proton-extra <steam root> <url of an aarch64 tarball>
|
||||
# droiddeck-proton-extra <steam root> /path/to/an/aarch64/tarball
|
||||
# droiddeck-proton-extra <steam root> --list what is installed now
|
||||
#
|
||||
# Both projects publish native ARM64 builds - GloriousEggroll as "*-aarch64.tar.gz", CachyOS as
|
||||
# "*-arm64.tar.xz" - and both are ordinary Proton trees: a python entry point beside a files/
|
||||
@@ -16,7 +16,7 @@
|
||||
# What it cannot use is their toolmanifest. Like Valve's ARM64 depot they declare
|
||||
# require_tool_appid, which makes Steam stack pressure-vessel underneath - and pressure-vessel
|
||||
# needs unprivileged user namespaces, which an Android app does not get. Patching that out is
|
||||
# bannerlator-steam-compat's job (adopt_extras); this script only puts the tree in place and then
|
||||
# steam-compatibility's job (adopt_extras); this script only puts the tree in place and then
|
||||
# calls it, so an install is usable without restarting the client.
|
||||
import hashlib
|
||||
import json
|
||||
@@ -36,14 +36,14 @@ SOURCES = {
|
||||
"ge": ("GloriousEggroll/proton-ge-custom", re.compile(r"aarch64\.tar\.(gz|xz)$")),
|
||||
"cachyos": ("CachyOS/proton-cachyos", re.compile(r"arm64\.tar\.(gz|xz)$")),
|
||||
}
|
||||
USER_AGENT = "bannerlator-proton-extra"
|
||||
USER_AGENT = "droiddeck-proton-extra"
|
||||
# Room for the tarball and the tree it unpacks to. GE-Proton's aarch64 build is ~650 MB packed and
|
||||
# unpacks to about three times that; refusing early beats a half-written tool directory.
|
||||
NEED_BYTES = 4 * 1024 * 1024 * 1024
|
||||
|
||||
|
||||
def log(*args):
|
||||
print("bannerlator-proton-extra:", *args, flush=True)
|
||||
print("droiddeck-proton-extra:", *args, flush=True)
|
||||
|
||||
|
||||
def fetch_json(url):
|
||||
@@ -77,7 +77,7 @@ def release_asset(source, tag):
|
||||
sums = [u for n, u in assets.items()
|
||||
if n.startswith(name.split(".tar")[0]) and "sha512" in n]
|
||||
return tag, assets[name], (sums[0] if sums else None)
|
||||
raise SystemExit("bannerlator-proton-extra: %s has no ARM64 asset" % tag)
|
||||
raise SystemExit("droiddeck-proton-extra: %s has no ARM64 asset" % tag)
|
||||
|
||||
|
||||
def download(url, path):
|
||||
@@ -88,7 +88,7 @@ def download(url, path):
|
||||
"curl", "-fL", "--retry", "5", "--retry-delay", "3", "--retry-connrefused",
|
||||
"-C", "-", "-A", USER_AGENT, "-o", path, url])
|
||||
if rc != 0:
|
||||
raise SystemExit("bannerlator-proton-extra: download failed (curl %d)" % rc)
|
||||
raise SystemExit("droiddeck-proton-extra: download failed (curl %d)" % rc)
|
||||
log("downloaded %.0f MB" % (os.path.getsize(path) / 1048576.0))
|
||||
|
||||
|
||||
@@ -109,7 +109,7 @@ def verify(path, sums_url):
|
||||
h.update(chunk)
|
||||
if h.hexdigest() != want:
|
||||
os.unlink(path)
|
||||
raise SystemExit("bannerlator-proton-extra: checksum mismatch; the download was deleted")
|
||||
raise SystemExit("droiddeck-proton-extra: checksum mismatch; the download was deleted")
|
||||
log("checksum ok")
|
||||
|
||||
|
||||
@@ -118,7 +118,7 @@ def extract(tarball, into):
|
||||
log("unpacking (a few minutes; nothing is shown while tar runs)")
|
||||
rc = subprocess.call(["tar", "-xf", tarball, "-C", into])
|
||||
if rc != 0:
|
||||
raise SystemExit("bannerlator-proton-extra: tar failed (%d)" % rc)
|
||||
raise SystemExit("droiddeck-proton-extra: tar failed (%d)" % rc)
|
||||
# A Proton tarball holds one top-level directory. Take whichever entry has the entry point so a
|
||||
# stray ._ file or a nested layout does not decide it.
|
||||
entries = [e for e in sorted(os.listdir(into)) if not e.startswith(".")]
|
||||
@@ -128,7 +128,7 @@ def extract(tarball, into):
|
||||
return path
|
||||
if len(entries) == 1 and os.path.isdir(os.path.join(into, entries[0])):
|
||||
return os.path.join(into, entries[0])
|
||||
raise SystemExit("bannerlator-proton-extra: no Proton tree in the archive")
|
||||
raise SystemExit("droiddeck-proton-extra: no Proton tree in the archive")
|
||||
|
||||
|
||||
def installed(tools):
|
||||
@@ -144,7 +144,7 @@ def installed(tools):
|
||||
def main():
|
||||
argv = sys.argv[1:]
|
||||
if not argv:
|
||||
raise SystemExit(__doc__ or "usage: bannerlator-proton-extra <steam root> ge|cachyos|<url>")
|
||||
raise SystemExit(__doc__ or "usage: droiddeck-proton-extra <steam root> ge|cachyos|<url>")
|
||||
steam_root = argv.pop(0)
|
||||
tools = os.path.join(steam_root, "compatibilitytools.d")
|
||||
os.makedirs(tools, exist_ok=True)
|
||||
@@ -167,7 +167,7 @@ def main():
|
||||
if what in SOURCES:
|
||||
tag, url, sums = release_asset(what, tag) if tag else pick_asset(what)
|
||||
if not url:
|
||||
raise SystemExit("bannerlator-proton-extra: no ARM64 build published for %s" % what)
|
||||
raise SystemExit("droiddeck-proton-extra: no ARM64 build published for %s" % what)
|
||||
log("%s -> %s" % (what, tag))
|
||||
elif what.startswith("http"):
|
||||
url, sums = what, None
|
||||
@@ -176,14 +176,15 @@ def main():
|
||||
log("using %s" % what)
|
||||
else:
|
||||
raise SystemExit(
|
||||
"bannerlator-proton-extra: expected ge, cachyos, a URL or a tarball path, got %r" % what)
|
||||
"droiddeck-proton-extra: expected ge, cachyos, a URL or a tarball path, got %r" % what)
|
||||
|
||||
free = shutil.disk_usage(tools).free
|
||||
if free < NEED_BYTES:
|
||||
raise SystemExit("bannerlator-proton-extra: needs about %d GB free, has %.1f GB" % (
|
||||
raise SystemExit("droiddeck-proton-extra: needs about %d GB free, has %.1f GB" % (
|
||||
NEED_BYTES // (1024 ** 3), free / float(1024 ** 3)))
|
||||
|
||||
staging = os.path.join(tools, ".bannerlator-download")
|
||||
shutil.rmtree(os.path.join(tools, ".bannerlator-download"), ignore_errors=True)
|
||||
staging = os.path.join(tools, ".droiddeck-download")
|
||||
os.makedirs(staging, exist_ok=True)
|
||||
if local:
|
||||
tarball = local
|
||||
@@ -210,7 +211,7 @@ def main():
|
||||
|
||||
# Patches out require_tool_appid and wraps the entry point, which is what makes it launchable
|
||||
# here. Doing it now means the client picks the tool up on its next restart with no extra step.
|
||||
subprocess.call(["bannerlator-steam-compat", steam_root])
|
||||
subprocess.call(["steam-compatibility", steam_root])
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
@@ -0,0 +1,51 @@
|
||||
#!/bin/bash
|
||||
# A script added on the Desktop page (UserApps), run from its own folder:
|
||||
# droiddeck-script-run /opt/droiddeck-apps/<id> [args...]
|
||||
set -u
|
||||
dir=${1:?usage: droiddeck-script-run <added app directory> [args...]}
|
||||
shift
|
||||
entry=$(cat "$dir/entry" 2>/dev/null) || { echo "droiddeck-script-run: $dir has no entry" >&2; exit 127; }
|
||||
cd -P "$dir/files" 2>/dev/null || { echo "droiddeck-script-run: $dir/files is missing; add the script again" >&2; exit 127; }
|
||||
folder=$PWD
|
||||
# Shared storage is noexec, so the script is handed to its interpreter rather than executed.
|
||||
first=
|
||||
IFS= read -r first < "$entry"
|
||||
first=${first%$'\r'}
|
||||
interp=(/bin/bash)
|
||||
case $first in '#!'*) read -r -a interp <<< "${first#'#!'}" ;; 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)"
|
||||
case ${DBUS_SESSION_BUS_ADDRESS:-} in
|
||||
unix:*) "${run[@]}" "$@" ;;
|
||||
*) unset DBUS_SESSION_BUS_ADDRESS
|
||||
if command -v dbus-run-session >/dev/null 2>&1; then
|
||||
dbus-run-session -- "${run[@]}" "$@"
|
||||
else
|
||||
"${run[@]}" "$@"
|
||||
fi ;;
|
||||
esac
|
||||
rc=$?
|
||||
# A launcher script often starts the game and returns; the session lasts while it runs.
|
||||
running() {
|
||||
local p exe arg cwd
|
||||
for p in /proc/[0-9]*; do
|
||||
exe=$(readlink "$p/exe" 2>/dev/null) || continue
|
||||
case $exe in "$folder"/*) return 0 ;; esac
|
||||
case $exe in
|
||||
*/FEX|*/FEXInterpreter)
|
||||
arg=$(tr '\0' '\n' < "$p/cmdline" 2>/dev/null | sed -n 2p)
|
||||
cwd=$(readlink "$p/cwd" 2>/dev/null)
|
||||
case $arg in "$folder"/*) return 0 ;; esac
|
||||
case $cwd in "$folder"|"$folder"/*) return 0 ;; esac
|
||||
;;
|
||||
esac
|
||||
done
|
||||
return 1
|
||||
}
|
||||
while running; do sleep 2; done
|
||||
exit $rc
|
||||
+5
-1
@@ -81,7 +81,11 @@ for reg in "$steam_root"/steamapps/common/Proton*/files/share/default_pfx*/syste
|
||||
"$steam_root"/steamapps/compatdata/*/pfx/system.reg \
|
||||
/mnt/droiddeck-sd/steamapps/compatdata/*/pfx/system.reg; do
|
||||
[ -f "$reg" ] || continue
|
||||
seeded=$(dirname "$reg")/.bannerlator-redists
|
||||
seeded=$(dirname "$reg")/.droiddeck-redists
|
||||
legacy=$(dirname "$reg")/.bannerlator-redists
|
||||
if [ -f "$legacy" ] && [ ! -f "$seeded" ]; then
|
||||
mv -f "$legacy" "$seeded"
|
||||
fi
|
||||
[ "$(cat "$seeded" 2>/dev/null)" = "$stamp" ] && continue
|
||||
dated=$(mktemp) || continue
|
||||
touch -r "$reg" "$dated"
|
||||
+76
-46
@@ -1,10 +1,10 @@
|
||||
#!/bin/bash
|
||||
# The Linux runtime's session. Bannerlator execs this under proot with the output size and mode;
|
||||
# The Linux runtime's session. DroidDeck execs this under proot with the output size and mode;
|
||||
# the first pass starts gamescope, which execs this script again inside it for the program:
|
||||
# bannerlator-session desktop the file manager
|
||||
# bannerlator-session run <path> a Linux program (AppImage, script or ELF)
|
||||
# bannerlator-session steam [steam-url] the native Steam client
|
||||
# bannerlator-session lxqt the LXQt/labwc desktop (DroidDeck's desktop package)
|
||||
# droiddeck-session desktop the file manager
|
||||
# droiddeck-session run <path> a Linux program (AppImage, script or ELF)
|
||||
# droiddeck-session steam [steam-url] the native Steam client
|
||||
# droiddeck-session lxqt the LXQt/labwc desktop (DroidDeck's desktop package)
|
||||
# BL_WIDTH / BL_HEIGHT size the output, BL_FPS limits it, BL_LOG collects everything said here.
|
||||
set -u
|
||||
export HOME=${HOME:-/root}
|
||||
@@ -22,8 +22,8 @@ if [ -n "${BL_LOG:-}" ] && [ -z "${BL_INSIDE:-}" ]; then
|
||||
# A guest looping on an error writes gigabytes in minutes (an Xwayland proot had lost track of
|
||||
# managed 9 GB of one line in 19 min): the log keeps its first BL_LOG_CAP bytes and the rest is
|
||||
# drained, not refused - a writer that filled it must not die of SIGPIPE.
|
||||
exec > >({ head -c "${BL_LOG_CAP:-268435456}" >>"$BL_LOG"; cat >/dev/null; }) 2>&1
|
||||
echo "== bannerlator-session $(date) mode=$mode $*"
|
||||
exec > >({ dd of="$BL_LOG" oflag=append conv=notrunc iflag=count_bytes count="${BL_LOG_CAP:-268435456}" bs=65536 status=none; cat >/dev/null; }) 2>&1
|
||||
echo "== droiddeck-session $(date) mode=$mode $*"
|
||||
echo "== uid=$(id -u) size=${BL_WIDTH:-?}x${BL_HEIGHT:-?} fps=${BL_FPS:-0} icd=${VK_ICD_FILENAMES:-none}"
|
||||
echo "== gamescope: $(gamescope --version 2>&1 | head -1) at $(command -v gamescope)"
|
||||
echo "== rootfs: $(cat /.version 2>/dev/null || echo unversioned)"
|
||||
@@ -42,6 +42,16 @@ collect_steam_logs() {
|
||||
[ -f "$HOME/.steam/steam/logs/steamwebhelper.log" ] && cp "$HOME/.steam/steam/logs/steamwebhelper.log" "$BL_DEBUG_DIR/steam/" 2>/dev/null
|
||||
# NOT copied, ever: loginusers.vdf, config.vdf and the ssfn* files, which hold the credentials
|
||||
# themselves rather than a mention of them.
|
||||
local sync_store=$HOME/.local/share/droiddeck-esync sync_file
|
||||
if [ -d "$sync_store" ] && mkdir -p "$BL_DEBUG_DIR/droiddeck-esync" 2>/dev/null; then
|
||||
for sync_file in launches.log tools.tsv wanted.tsv prefixes.json; do
|
||||
[ -f "$sync_store/$sync_file" ] && cp "$sync_store/$sync_file" "$BL_DEBUG_DIR/droiddeck-esync/" 2>/dev/null
|
||||
done
|
||||
fi
|
||||
local fex_state=$HOME/.local/share/droiddeck-fex
|
||||
if [ -d "$fex_state" ] && mkdir -p "$BL_DEBUG_DIR/droiddeck-fex" 2>/dev/null; then
|
||||
cp "$fex_state/status.json" "$fex_state/config/Config.json" "$BL_DEBUG_DIR/droiddeck-fex/" 2>/dev/null
|
||||
fi
|
||||
echo "== steam logs copied to $BL_DEBUG_DIR/steam"
|
||||
}
|
||||
# A session that is killed never reaches the copy below, and those are the sessions worth reading.
|
||||
@@ -93,11 +103,11 @@ export XDG_CONFIG_HOME=${XDG_CONFIG_HOME:-$HOME/.config}
|
||||
export XDG_CACHE_HOME=${XDG_CACHE_HOME:-$HOME/.cache}
|
||||
mkdir -p "$XDG_DATA_HOME" "$XDG_CONFIG_HOME" "$XDG_CACHE_HOME"
|
||||
if [ "$mode" = lxqt ] || [ "$mode" = desktop ]; then
|
||||
/usr/local/bin/bannerlator-desktop-bookmarks || true
|
||||
/usr/local/bin/droiddeck-desktop-bookmarks || true
|
||||
fi
|
||||
# Flatpak (the store's apps): its sandboxes through the app instead of bubblewrap, which needs the
|
||||
# user namespaces Android keeps from apps, and its apps' menu entries and icons on the desktop.
|
||||
export FLATPAK_BWRAP=/usr/local/bin/bannerlator-bwrap
|
||||
export FLATPAK_BWRAP=/usr/local/bin/droiddeck-bwrap
|
||||
export XDG_DATA_DIRS=$XDG_DATA_HOME/flatpak/exports/share:${XDG_DATA_DIRS:-/usr/local/share:/usr/share}
|
||||
|
||||
# The cores a program runs on outside Steam (the desktop and everything started from it, a
|
||||
@@ -238,32 +248,41 @@ case $mode in
|
||||
taskset -cp "$cores" $$ >/dev/null 2>&1 || true
|
||||
fi
|
||||
# Player 1 on the controller in an emulator that has no profile of its own yet.
|
||||
python3 /usr/local/bin/bannerlator-pad-defaults 2>&1 || true
|
||||
python3 /usr/local/bin/droiddeck-pad-defaults 2>&1 || true
|
||||
fex=()
|
||||
if [ -x /usr/local/bin/droiddeck-fex ]; then
|
||||
case $(od -An -tu2 -j18 -N2 "$target" 2>/dev/null | tr -d ' ') in
|
||||
3|62) fex=(/usr/local/bin/droiddeck-fex run --mode on --) ;;
|
||||
esac
|
||||
fi
|
||||
case ${target,,} in
|
||||
*.appimage)
|
||||
export APPIMAGE_EXTRACT_AND_RUN=1
|
||||
chmod +x "$target" 2>/dev/null
|
||||
exec "$target" "$@"
|
||||
exec "${fex[@]}" "$target" "$@"
|
||||
;;
|
||||
*.sh)
|
||||
if [ -x /usr/local/bin/droiddeck-fex ]; then
|
||||
exec /usr/local/bin/droiddeck-fex run --for "$target" -- bash "$target" "$@"
|
||||
fi
|
||||
exec bash "$target" "$@"
|
||||
;;
|
||||
*)
|
||||
chmod +x "$target" 2>/dev/null
|
||||
cd "$(dirname "$target")" && exec "$target" "$@"
|
||||
cd "$(dirname "$target")" && exec "${fex[@]}" "$target" "$@"
|
||||
;;
|
||||
esac
|
||||
;;
|
||||
steam)
|
||||
step "checking the Steam client (first run downloads it, ~1-2 min with nothing on screen)"
|
||||
bannerlator-steam-install || exit $?
|
||||
droiddeck-steam-install || exit $?
|
||||
step "Steam client ready"
|
||||
steam_root=$XDG_DATA_HOME/Steam
|
||||
# Register the card library (bound at /mnt/droiddeck-sd) with the client - internal storage is
|
||||
# its main library already - and the ARM64 Proton that lets it launch the Windows ones.
|
||||
# A request left in ~/.bl-proton-extra installs a third-party Proton before the client starts,
|
||||
# so it is in the Compatibility dropdown the first time the user looks. One per line, each the
|
||||
# arguments to bannerlator-proton-extra: "ge", "cachyos", "ge --tag GE-Proton11-7", or a URL.
|
||||
# arguments to droiddeck-proton-extra: "ge", "cachyos", "ge --tag GE-Proton11-7", or a URL.
|
||||
# Hundreds of megabytes each, so it is only ever done on request, and the line is dropped once
|
||||
# it has succeeded - a failed download stays and is retried next session.
|
||||
if [ -s "$HOME/.bl-proton-extra" ]; then
|
||||
@@ -272,7 +291,7 @@ case $mode in
|
||||
while read -r _bl_extra || [ -n "$_bl_extra" ]; do
|
||||
case ${_bl_extra# } in ""|"#"*) continue ;; esac
|
||||
step "installing Proton '$_bl_extra' (large download, several minutes)"
|
||||
if bannerlator-proton-extra "$steam_root" $_bl_extra; then
|
||||
if droiddeck-proton-extra "$steam_root" $_bl_extra; then
|
||||
step "installed Proton '$_bl_extra'"
|
||||
else
|
||||
step "Proton '$_bl_extra' failed; will retry next session"
|
||||
@@ -323,27 +342,27 @@ case $mode in
|
||||
fi
|
||||
|
||||
step "registering the app's game library with Steam"
|
||||
bannerlator-steam-library "$steam_root" || true
|
||||
droiddeck-steam-library "$steam_root" || true
|
||||
step "setting up the ARM64 Proton compatibility tool"
|
||||
bannerlator-steam-compat "$steam_root" || true
|
||||
steam-compatibility "$steam_root" || true
|
||||
if [ -z "${BL_DESKTOP:-}" ] && [ "${BL_STEAM_UI:-}" != desktop ]; then
|
||||
bannerlator-steam-ui-scale "$steam_root" "${BL_WIDTH:-1280}" "${BL_HEIGHT:-720}" || true
|
||||
droiddeck-steam-ui-scale "$steam_root" "${BL_WIDTH:-1280}" "${BL_HEIGHT:-720}" || true
|
||||
fi
|
||||
# The user's own games, as non-Steam shortcuts under that tool; the list is written by the app
|
||||
# each session (empty = the app's earlier entries are removed, the client's own are kept).
|
||||
if [ -n "${BL_ADDED_GAMES:-}" ]; then
|
||||
step "adding the app's own games to the client's library"
|
||||
bannerlator-steam-shortcuts "$steam_root" "$BL_ADDED_GAMES" || true
|
||||
droiddeck-steam-shortcuts "$steam_root" "$BL_ADDED_GAMES" || true
|
||||
fi
|
||||
# Steam runs a game's shared redistributables inside its prefix on first launch; marking
|
||||
# them as already run keeps those x86 installers from starting under emulation at all.
|
||||
bannerlator-seed-redists "$steam_root" || true
|
||||
droiddeck-seed-redists "$steam_root" || true
|
||||
# The compatibility tool runs Valve's arm64 Proton, which the client fetches like any depot.
|
||||
# Asked for on the command line the first time, so a Windows title has it before it is needed.
|
||||
if [ ! -f "$steam_root/steamapps/appmanifest_4427310.acf" ]; then
|
||||
step "asking the client to fetch the ARM64 Proton"
|
||||
set -- "$@" steam://install/4427310
|
||||
# Ported from Bannerlator (bannerlator-session, device-proven 2026-09-22). The client decides
|
||||
# Ported from Bannerlator's session script (device-proven 2026-09-22). The client decides
|
||||
# a title's compatibility tool when the title is installed and keeps that decision for the
|
||||
# rest of its run, and the tool is set up before the client comes up. So once the depot has
|
||||
# fully landed, restart the client once - its own -shutdown, then the loop below, which knows
|
||||
@@ -357,7 +376,7 @@ case $mode in
|
||||
# StateFlags 4 = fully installed; a moment more for the client to finish its bookkeeping.
|
||||
if grep -q '"StateFlags"[[:space:]]*"4"' "$_bl_acf" 2>/dev/null; then
|
||||
sleep 10
|
||||
bannerlator-steam-compat "$steam_root" >/dev/null 2>&1 || true
|
||||
steam-compatibility "$steam_root" >/dev/null 2>&1 || true
|
||||
step "compatibility layer installed: restarting the Steam client once"
|
||||
: > "$HOME/.bl-restart-once"
|
||||
"$steam_root/steamrtarm64/steam" -shutdown >/dev/null 2>&1 || true
|
||||
@@ -514,10 +533,10 @@ case $mode in
|
||||
nap 5
|
||||
beat=$((beat + 1))
|
||||
[ "$((beat % 3))" -eq 0 ] || continue
|
||||
bannerlator-seed-redists "$steam_root" >/dev/null 2>&1 || true
|
||||
droiddeck-seed-redists "$steam_root" >/dev/null 2>&1 || true
|
||||
if compat_due; then
|
||||
: > "$compat_stamp"
|
||||
bannerlator-steam-compat "$steam_root" >/dev/null 2>&1 || true
|
||||
steam-compatibility "$steam_root" >/dev/null 2>&1 || true
|
||||
fi
|
||||
done
|
||||
) &
|
||||
@@ -542,9 +561,9 @@ case $mode in
|
||||
# refuses what it cannot do, since the app has no say over Wi-Fi - answer what the client asks.
|
||||
# The bus config is written here rather than shipped, so a runtime installed earlier gets this
|
||||
# from the app's copy of the session scripts without a re-host. (WinNative, maxjivi05, e7a224ae.)
|
||||
if command -v dbus-daemon >/dev/null 2>&1 && command -v bannerlator-netmanager >/dev/null 2>&1; then
|
||||
mkdir -p /run/dbus /usr/local/share/bannerlator
|
||||
cat > /usr/local/share/bannerlator/system-bus.conf <<'BUSCONF'
|
||||
if command -v dbus-daemon >/dev/null 2>&1 && command -v droiddeck-netmanager >/dev/null 2>&1; then
|
||||
mkdir -p /run/dbus /usr/local/share/droiddeck
|
||||
cat > /usr/local/share/droiddeck/system-bus.conf <<'BUSCONF'
|
||||
<!DOCTYPE busconfig PUBLIC "-//freedesktop//DTD D-Bus Bus Configuration 1.0//EN"
|
||||
"http://www.freedesktop.org/standards/dbus/1.0/busconfig.dtd">
|
||||
<busconfig>
|
||||
@@ -560,21 +579,21 @@ case $mode in
|
||||
</busconfig>
|
||||
BUSCONF
|
||||
rm -f /run/dbus/system_bus_socket
|
||||
dbus-daemon --config-file=/usr/local/share/bannerlator/system-bus.conf --nofork --nopidfile &
|
||||
dbus-daemon --config-file=/usr/local/share/droiddeck/system-bus.conf --nofork --nopidfile &
|
||||
system_bus=$!
|
||||
for _ in $(seq 1 50); do
|
||||
[ -S /run/dbus/system_bus_socket ] && break
|
||||
sleep 0.1
|
||||
done
|
||||
if [ -S /run/dbus/system_bus_socket ]; then
|
||||
bannerlator-netmanager &
|
||||
droiddeck-netmanager &
|
||||
netmanager=$!
|
||||
echo "== network: system bus up, NetworkManager stand-in running"
|
||||
# Steam blanks its main UI before calling login1.Suspend. Without the
|
||||
# matching resume notification it stays black although the menus work.
|
||||
# Own the name before Steam constructs its login1 proxy at startup.
|
||||
rm -f "$BL_LAUNCH_DIR/steam-sleep-ready"
|
||||
bannerlator-login1 &
|
||||
droiddeck-login1 &
|
||||
login_manager=$!
|
||||
for ((_i = 0; _i < 50; _i++)); do
|
||||
[ -f "$BL_LAUNCH_DIR/steam-sleep-ready" ] && break
|
||||
@@ -598,26 +617,20 @@ BUSCONF
|
||||
export STEAM_RUNTIME=1
|
||||
export LD_LIBRARY_PATH=$steam_root/steamrtarm64:$steam_root/steamrtarm64/panorama${LD_LIBRARY_PATH:+:$LD_LIBRARY_PATH}
|
||||
export SDL_VIDEO_X11_DGAMOUSE=0
|
||||
# Native-Linux x86 games go through Valve's FEX compat tool, which runs FEX with FEX_PORTABLE=1
|
||||
# - that makes FEX look for its config next to the binary, while the tool writes one into the
|
||||
# app's compatdata instead. FEX therefore starts with no rootfs, every x86_64 library lookup
|
||||
# falls through to the host, and the guest shell dies on libreadline before the game is reached.
|
||||
# FEX_ROOTFS names it outright and is read whatever the config situation.
|
||||
[ -d /usr/share/guestos/fex-mesa ] && export FEX_ROOTFS=/usr/share/guestos/fex-mesa
|
||||
# Decky is optional and session scoped: the app's marker opts in, and this supervisor is
|
||||
# reaped with the client session. Native ARM64 runs directly. A legacy x86_64 asset is used
|
||||
# only when its recorded architecture and this guest's existing FEX installation agree.
|
||||
# only when its recorded architecture says so and droiddeck-fex has FEX and its runtime ready.
|
||||
decky_loader=$HOME/homebrew/services/PluginLoader
|
||||
if [ -f "$HOME/.droiddeck-decky-enabled" ] && [ -x "$decky_loader" ]; then
|
||||
decky_arch=$(cat "$HOME/homebrew/services/.droiddeck-decky-arch" 2>/dev/null || echo unknown)
|
||||
if [ "$decky_arch" = arm64 ] || { [ "$decky_arch" = x86_64 ] && [ -x /usr/bin/FEX ] && [ -n "${FEX_ROOTFS:-}" ]; }; then
|
||||
if [ "$decky_arch" = arm64 ] || { [ "$decky_arch" = x86_64 ] && /usr/local/bin/droiddeck-fex prepare >/dev/null; }; then
|
||||
(
|
||||
decky_child=
|
||||
decky_stop() { [ -z "$decky_child" ] || kill "$decky_child" 2>/dev/null; [ -z "$decky_child" ] || wait "$decky_child" 2>/dev/null; exit 0; }
|
||||
trap decky_stop TERM INT HUP
|
||||
decky_exits=0
|
||||
while :; do
|
||||
if [ "$decky_arch" = x86_64 ]; then /usr/bin/FEX "$decky_loader" >>"$HOME/homebrew/services/PluginLoader.log" 2>&1 &
|
||||
if [ "$decky_arch" = x86_64 ]; then /usr/local/bin/droiddeck-fex run --mode on -- "$decky_loader" >>"$HOME/homebrew/services/PluginLoader.log" 2>&1 &
|
||||
else "$decky_loader" >>"$HOME/homebrew/services/PluginLoader.log" 2>&1 &
|
||||
fi
|
||||
decky_child=$!
|
||||
@@ -640,6 +653,20 @@ BUSCONF
|
||||
echo "== Decky: installed loader architecture is unsupported by this guest; not starting"
|
||||
fi
|
||||
fi
|
||||
_bl_cdp=()
|
||||
if [ -f "$steam_root/.cef-enable-remote-debugging" ]; then
|
||||
export BL_CDP_PORT=8080
|
||||
else
|
||||
export BL_CDP_PORT=$((20000 + RANDOM % 30000))
|
||||
_bl_cdp=(-cef-enable-debugging -devtools-port "$BL_CDP_PORT")
|
||||
fi
|
||||
if [ -f "$HOME/.droiddeck-decky-enabled" ] && [ "${decky_arch:-}" = x86_64 ]; then
|
||||
echo "== steam: devtools port $BL_CDP_PORT left open for the x86_64 Decky loader"
|
||||
else
|
||||
export BL_CDP_GUARD=$BL_CDP_PORT
|
||||
echo "== steam: devtools port $BL_CDP_PORT, guest processes only"
|
||||
fi
|
||||
droiddeck-steam-compat "$steam_root" 2>&1 &
|
||||
# The client exits 42 when it has updated itself and wants a fresh start (steam.sh does this).
|
||||
# BL_STEAM_UI=desktop = the client's desktop UI (a window, the library as a list), which the
|
||||
# desktop's launchers ask for; gamescope shows one window at a time and the game takes over.
|
||||
@@ -682,7 +709,7 @@ BUSCONF
|
||||
steam_channel=${BL_STEAM_CHANNEL:-steamdeck_publicbeta}
|
||||
steam_beta=$steam_root/package/beta
|
||||
if [ -n "${BL_ADDED_GAMES:-}" ] && [ -f "$BL_ADDED_GAMES" ]; then
|
||||
bannerlator-steam-games watch "$steam_root" "$BL_ADDED_GAMES" &
|
||||
droiddeck-steam-games watch "$steam_root" "$BL_ADDED_GAMES" &
|
||||
games_watcher=$!
|
||||
fi
|
||||
# Lossless Scaling (Steam app 993090): whether this account owns it, asked of the signed-in
|
||||
@@ -694,7 +721,7 @@ BUSCONF
|
||||
for ((_i = 0; _i < 60; _i++)); do
|
||||
nap 30
|
||||
[ -e "$owned" ] && exit 0
|
||||
answer=$(bannerlator-steam-games probe "$steam_root" 993090 2>/dev/null) || 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" ;;
|
||||
*) echo "== Lossless Scaling: not owned by this account" ;;
|
||||
@@ -703,7 +730,7 @@ BUSCONF
|
||||
done
|
||||
) &
|
||||
fi
|
||||
echo "== steam args: ${_bl_ui[*]} -clientbeta $steam_channel -no-cef-sandbox -cef-force-gpu -cef-ozone-platform=x11 -cef-use-gl=angle -cef-use-angle=vulkan $*"
|
||||
echo "== steam args: ${_bl_ui[*]} ${_bl_cdp[*]} -clientbeta $steam_channel -no-cef-sandbox -cef-force-gpu -cef-ozone-platform=x11 -cef-use-gl=angle -cef-use-angle=vulkan $*"
|
||||
# An update that cannot install asks for a restart (rc=42) every time; the count is capped so a
|
||||
# session can never again loop in silence, which reads as a menu opening and closing by itself.
|
||||
steam_updates=0
|
||||
@@ -749,14 +776,17 @@ BUSCONF
|
||||
echo "$steam_channel" > "$steam_beta"
|
||||
fi
|
||||
step "starting the Steam client${BL_STEAM_UI:+ ($BL_STEAM_UI UI)}"
|
||||
"$steam_root/steamrtarm64/steam" "${_bl_ui[@]}" -clientbeta "$steam_channel" \
|
||||
"$steam_root/steamrtarm64/steam" "${_bl_ui[@]}" "${_bl_cdp[@]}" -clientbeta "$steam_channel" \
|
||||
-no-cef-sandbox -cef-force-gpu -cef-ozone-platform=x11 \
|
||||
-cef-use-gl=angle -cef-use-angle=vulkan "$@"
|
||||
rc=$?
|
||||
echo "== steam exited rc=$rc"
|
||||
collect_steam_logs
|
||||
if [ -f "$HOME/.config/droiddeck/fex-wanted" ] && [ -x /usr/local/bin/droiddeck-fex ]; then
|
||||
/usr/local/bin/droiddeck-fex status >/dev/null 2>&1 || true
|
||||
fi
|
||||
if [ -n "${BL_ADDED_GAMES:-}" ] && [ -f "$BL_ADDED_GAMES" ]; then
|
||||
bannerlator-steam-shortcuts "$steam_root" "$BL_ADDED_GAMES" || true
|
||||
droiddeck-steam-shortcuts "$steam_root" "$BL_ADDED_GAMES" || true
|
||||
fi
|
||||
if [ -f "$HOME/.bl-stop-requested" ]; then
|
||||
rm -f "$HOME/.bl-stop-requested" "$HOME/.bl-restart-once"
|
||||
@@ -787,7 +817,7 @@ BUSCONF
|
||||
wait "$games_watcher" 2>/dev/null || true
|
||||
fi
|
||||
if [ -n "${BL_DESKTOP:-}" ]; then
|
||||
# Started from the desktop (bannerlator-steam-launch): the desktop's own programs share this
|
||||
# Started from the desktop (droiddeck-steam-launch): the desktop's own programs share this
|
||||
# script's parent, so reap_orphans - right under gamescope, where everything is the client's -
|
||||
# is not for here. The helpers this run started (the cores and redistributables beats, the
|
||||
# system bus and the NetworkManager stand-in) go with the client instead.
|
||||
@@ -812,7 +842,7 @@ BUSCONF
|
||||
exit "$rc"
|
||||
;;
|
||||
*)
|
||||
echo "bannerlator-session: unknown mode '$mode'" >&2
|
||||
echo "droiddeck-session: unknown mode '$mode'" >&2
|
||||
exit 64
|
||||
;;
|
||||
esac
|
||||
+496
@@ -0,0 +1,496 @@
|
||||
#!/usr/bin/python3
|
||||
import base64
|
||||
import ctypes
|
||||
import json
|
||||
import os
|
||||
import runpy
|
||||
import select
|
||||
import signal
|
||||
import socket
|
||||
import struct
|
||||
import sys
|
||||
import time
|
||||
|
||||
HERE = os.path.dirname(os.path.realpath(__file__))
|
||||
COMPAT = runpy.run_path(os.path.join(HERE, "steam-compatibility"))
|
||||
BINDING = "droiddeckCompatChanged"
|
||||
INSTALL_JS = r"""
|
||||
(() => {
|
||||
if (window.__droiddeckCompat) return "present";
|
||||
const enc = new TextEncoder(), dec = new TextDecoder();
|
||||
const varint = (value, out) => { let n = BigInt(value); do { let b = Number(n & 0x7fn); n >>= 7n; if (n) b |= 0x80; out.push(b); } while (n); };
|
||||
const key = (field, wire, out) => varint(field * 8 + wire, out);
|
||||
const str = (field, s, out) => { const b = enc.encode(s); key(field, 2, out); varint(b.length, out); for (const x of b) out.push(x); };
|
||||
const uint = (field, v, out) => { key(field, 0, out); varint(v, out); };
|
||||
const fixed64 = (field, v, out) => { key(field, 1, out); let n = BigInt(v); for (let i = 0; i < 8; i++) { out.push(Number(n & 0xffn)); n >>= 8n; } };
|
||||
const parse = (bytes) => {
|
||||
const fields = {};
|
||||
let i = 0;
|
||||
const read = () => { let r = 0n, s = 0n, b; do { b = bytes[i++]; r |= BigInt(b & 0x7f) << s; s += 7n; } while (b & 0x80); return r; };
|
||||
while (i < bytes.length) {
|
||||
const k = Number(read()), field = k >> 3, wire = k & 7;
|
||||
let v;
|
||||
if (wire === 0) v = read();
|
||||
else if (wire === 1) { v = 0n; for (let j = 0; j < 8; j++) v |= BigInt(bytes[i + j]) << BigInt(8 * j); i += 8; }
|
||||
else if (wire === 2) { const n = Number(read()); v = bytes.subarray(i, i + n); i += n; }
|
||||
else if (wire === 5) { v = bytes.subarray(i, i + 4); i += 4; }
|
||||
else throw new Error("unexpected wire type " + wire);
|
||||
(fields[field] = fields[field] || []).push(v);
|
||||
}
|
||||
return fields;
|
||||
};
|
||||
const text = (f, n) => f[n] ? dec.decode(f[n][0]) : "";
|
||||
const self = { seq: 0, pending: new Map(), ws: null, opening: null, changes: 0 };
|
||||
const frame = (method, body, auth) => {
|
||||
const h = [];
|
||||
fixed64(10, ++self.seq, h);
|
||||
str(12, method, h);
|
||||
if (auth) str(40, auth, h);
|
||||
const out = new Uint8Array(8 + h.length + body.length);
|
||||
const view = new DataView(out.buffer);
|
||||
view.setUint32(0, (0x80000000 | 146) >>> 0, true);
|
||||
view.setUint32(4, h.length, true);
|
||||
out.set(h, 8);
|
||||
out.set(body, 8 + h.length);
|
||||
return [self.seq, out];
|
||||
};
|
||||
const onMessage = (event) => {
|
||||
const bytes = new Uint8Array(event.data);
|
||||
const length = new DataView(event.data).getUint32(4, true);
|
||||
const header = parse(bytes.subarray(8, 8 + length));
|
||||
const target = header[11] ? Number(header[11][0] & 0xffffffffn) : -1;
|
||||
if (self.pending.has(target)) {
|
||||
const done = self.pending.get(target);
|
||||
self.pending.delete(target);
|
||||
const result = header[13] ? Number(header[13][0]) : 2;
|
||||
done(result === 1 ? { ok: true, body: parse(bytes.subarray(8 + length)) } : { ok: false, eresult: result, error: text(header, 14) });
|
||||
return;
|
||||
}
|
||||
if (text(header, 12).startsWith("CompatManager.NotifyStateChanged")) {
|
||||
self.changes++;
|
||||
if (typeof window.__BINDING__ === "function") window.__BINDING__(String(self.changes));
|
||||
}
|
||||
};
|
||||
const send = (method, body, auth) => new Promise((resolve, reject) => {
|
||||
const [id, out] = frame(method, Uint8Array.from(body), auth);
|
||||
const timer = setTimeout(() => { self.pending.delete(id); reject(new Error(method + " timed out")); }, 10000);
|
||||
self.pending.set(id, (r) => { clearTimeout(timer); resolve(r); });
|
||||
self.ws.send(out);
|
||||
});
|
||||
const open = async () => {
|
||||
const info = await SteamClient.WebUITransport.GetTransportInfo();
|
||||
const ws = new WebSocket("ws://127.0.0.1:" + info.portClientdll + "/transportsocket/");
|
||||
ws.binaryType = "arraybuffer";
|
||||
await new Promise((resolve, reject) => { ws.onopen = resolve; ws.onerror = () => reject(new Error("the client's transport refused the connection")); });
|
||||
ws.onmessage = onMessage;
|
||||
ws.onclose = () => {
|
||||
if (self.ws === ws) self.ws = null;
|
||||
for (const done of self.pending.values()) done({ ok: false, eresult: 0, error: "connection closed" });
|
||||
self.pending.clear();
|
||||
};
|
||||
self.ws = ws;
|
||||
const body = [];
|
||||
str(1, info.authKeyClientdll, body);
|
||||
const r = await send("TransportAuth.Authenticate#1", body, info.authKeyClientdll);
|
||||
if (!r.ok) { ws.close(); throw new Error("the client's transport refused authentication (" + r.eresult + ")"); }
|
||||
};
|
||||
const ready = async () => {
|
||||
if (self.ws && self.ws.readyState === 1) return;
|
||||
if (!self.opening) self.opening = open().finally(() => { self.opening = null; });
|
||||
await self.opening;
|
||||
};
|
||||
self.get = async (appid) => {
|
||||
await ready();
|
||||
const body = [];
|
||||
uint(1, appid, body);
|
||||
const r = await send("CompatManager.GetCompatTools#1", body);
|
||||
if (!r.ok) throw new Error("GetCompatTools " + appid + " failed (" + r.eresult + " " + r.error + ")");
|
||||
return { selected: text(r.body, 3), fallback: text(r.body, 4), tools: (r.body[1] || []).map((t) => text(parse(t), 1)) };
|
||||
};
|
||||
self.set = async (appid, name) => {
|
||||
await ready();
|
||||
const body = [];
|
||||
uint(1, appid, body);
|
||||
str(2, name, body);
|
||||
const r = await send("CompatManager.SpecifyCompatTool#1", body);
|
||||
if (!r.ok) throw new Error("SpecifyCompatTool " + appid + " " + name + " failed (" + r.eresult + " " + r.error + ")");
|
||||
return true;
|
||||
};
|
||||
self.many = async (apps) => {
|
||||
const out = {};
|
||||
for (const app of apps) out[app] = (await self.get(Number(app))).selected;
|
||||
return out;
|
||||
};
|
||||
window.__droiddeckCompat = self;
|
||||
return "installed";
|
||||
})()
|
||||
""".replace("__BINDING__", BINDING)
|
||||
|
||||
|
||||
class Closed(Exception):
|
||||
pass
|
||||
|
||||
|
||||
def say(message):
|
||||
print("droiddeck-steam-compat: %s" % message, flush=True)
|
||||
|
||||
|
||||
def connect(port, timeout=5):
|
||||
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
|
||||
sock.settimeout(timeout)
|
||||
try:
|
||||
sock.bind(("127.0.0.1", 0))
|
||||
sock.connect(("127.0.0.1", port))
|
||||
except OSError:
|
||||
sock.close()
|
||||
raise
|
||||
return sock
|
||||
|
||||
|
||||
def http_get(port, path):
|
||||
sock = connect(port)
|
||||
try:
|
||||
sock.sendall(("GET %s HTTP/1.1\r\nHost: 127.0.0.1:%d\r\nConnection: close\r\n\r\n" % (path, port)).encode())
|
||||
data = b""
|
||||
length = None
|
||||
while length is None or len(data) < length:
|
||||
chunk = sock.recv(65536)
|
||||
if not chunk:
|
||||
break
|
||||
data += chunk
|
||||
if length is None and b"\r\n\r\n" in data:
|
||||
head, _, rest = data.partition(b"\r\n\r\n")
|
||||
for line in head.split(b"\r\n")[1:]:
|
||||
name, _, value = line.partition(b":")
|
||||
if name.strip().lower() == b"content-length":
|
||||
length = int(value.strip())
|
||||
if length is None:
|
||||
length = float("inf")
|
||||
data = rest
|
||||
if not head.startswith(b"HTTP/1.1 200"):
|
||||
raise OSError("devtools answered %r" % head[:40])
|
||||
finally:
|
||||
sock.close()
|
||||
return json.loads(data.decode("utf-8", "replace"))
|
||||
|
||||
|
||||
class WebSocket:
|
||||
def __init__(self, port, path):
|
||||
self.sock = connect(port)
|
||||
key = base64.b64encode(os.urandom(16)).decode()
|
||||
self.sock.sendall(("GET %s HTTP/1.1\r\nHost: 127.0.0.1:%d\r\nUpgrade: websocket\r\nConnection: Upgrade\r\n"
|
||||
"Sec-WebSocket-Key: %s\r\nSec-WebSocket-Version: 13\r\n\r\n" % (path, port, key)).encode())
|
||||
self.buffer = b""
|
||||
while b"\r\n\r\n" not in self.buffer:
|
||||
self.fill()
|
||||
head, _, self.buffer = self.buffer.partition(b"\r\n\r\n")
|
||||
if not head.startswith(b"HTTP/1.1 101"):
|
||||
raise OSError("devtools refused the websocket: %r" % head[:60])
|
||||
self.sock.settimeout(None)
|
||||
|
||||
def fileno(self):
|
||||
return self.sock.fileno()
|
||||
|
||||
def fill(self):
|
||||
chunk = self.sock.recv(65536)
|
||||
if not chunk:
|
||||
raise Closed("devtools closed the connection")
|
||||
self.buffer += chunk
|
||||
|
||||
def take(self, n):
|
||||
while len(self.buffer) < n:
|
||||
self.fill()
|
||||
data, self.buffer = self.buffer[:n], self.buffer[n:]
|
||||
return data
|
||||
|
||||
def send(self, text, opcode=1):
|
||||
payload = text.encode() if isinstance(text, str) else text
|
||||
mask = os.urandom(4)
|
||||
n = len(payload)
|
||||
if n < 126:
|
||||
head = struct.pack("!BB", 0x80 | opcode, 0x80 | n)
|
||||
elif n < 65536:
|
||||
head = struct.pack("!BBH", 0x80 | opcode, 0xFE, n)
|
||||
else:
|
||||
head = struct.pack("!BBQ", 0x80 | opcode, 0xFF, n)
|
||||
self.sock.sendall(head + mask + bytes(b ^ mask[i % 4] for i, b in enumerate(payload)))
|
||||
|
||||
def pending(self):
|
||||
return len(self.buffer) > 0
|
||||
|
||||
def recv(self):
|
||||
message = b""
|
||||
while True:
|
||||
first, second = self.take(2)
|
||||
n = second & 0x7F
|
||||
if n == 126:
|
||||
n = struct.unpack("!H", self.take(2))[0]
|
||||
elif n == 127:
|
||||
n = struct.unpack("!Q", self.take(8))[0]
|
||||
mask = self.take(4) if second & 0x80 else None
|
||||
payload = self.take(n)
|
||||
if mask:
|
||||
payload = bytes(b ^ mask[i % 4] for i, b in enumerate(payload))
|
||||
opcode = first & 0x0F
|
||||
if opcode == 8:
|
||||
raise Closed("devtools closed the websocket")
|
||||
if opcode == 9:
|
||||
self.send(payload, 10)
|
||||
continue
|
||||
if opcode == 10:
|
||||
continue
|
||||
message += payload
|
||||
if first & 0x80:
|
||||
return message.decode("utf-8", "replace")
|
||||
|
||||
def close(self):
|
||||
try:
|
||||
self.sock.close()
|
||||
except OSError:
|
||||
pass
|
||||
|
||||
|
||||
class Page:
|
||||
def __init__(self, port, path):
|
||||
self.ws = WebSocket(port, path)
|
||||
self.next_id = 0
|
||||
self.events = []
|
||||
|
||||
def call(self, method, params=None, timeout=30):
|
||||
self.next_id += 1
|
||||
mine = self.next_id
|
||||
self.ws.send(json.dumps({"id": mine, "method": method, "params": params or {}}))
|
||||
deadline = time.monotonic() + timeout
|
||||
while True:
|
||||
if not self.ws.pending():
|
||||
left = deadline - time.monotonic()
|
||||
if left <= 0 or not select.select([self.ws], [], [], left)[0]:
|
||||
raise TimeoutError("%s timed out" % method)
|
||||
message = json.loads(self.ws.recv())
|
||||
if message.get("id") == mine:
|
||||
if "error" in message:
|
||||
raise RuntimeError("%s: %s" % (method, message["error"].get("message")))
|
||||
return message.get("result", {})
|
||||
if "method" in message:
|
||||
self.events.append(message)
|
||||
|
||||
def evaluate(self, expression, timeout=30):
|
||||
result = self.call("Runtime.evaluate", {"expression": expression, "awaitPromise": True, "returnByValue": True}, timeout)
|
||||
if "exceptionDetails" in result:
|
||||
details = result["exceptionDetails"]
|
||||
raise RuntimeError((details.get("exception") or {}).get("description") or details.get("text") or "script failed")
|
||||
return result.get("result", {}).get("value")
|
||||
|
||||
def compat(self, call):
|
||||
return self.evaluate("%s;\nwindow.__droiddeckCompat.%s" % (INSTALL_JS, call))
|
||||
|
||||
def drain(self):
|
||||
while True:
|
||||
if not self.ws.pending() and not select.select([self.ws], [], [], 0)[0]:
|
||||
break
|
||||
message = json.loads(self.ws.recv())
|
||||
if "method" in message:
|
||||
self.events.append(message)
|
||||
events, self.events = self.events, []
|
||||
return events
|
||||
|
||||
|
||||
def shared_context(port):
|
||||
for target in http_get(port, "/json/list"):
|
||||
if target.get("title") == "SharedJSContext" and target.get("webSocketDebuggerUrl"):
|
||||
path = target["webSocketDebuggerUrl"].split("/", 3)[3]
|
||||
return "/" + path
|
||||
return None
|
||||
|
||||
|
||||
class Watcher:
|
||||
MASK = 0x00000008 | 0x00000080 | 0x00000100 | 0x00000200
|
||||
|
||||
def __init__(self, files):
|
||||
self.files = files
|
||||
self.fd = -1
|
||||
try:
|
||||
libc = ctypes.CDLL(None, use_errno=True)
|
||||
fd = libc.inotify_init1(os.O_NONBLOCK | os.O_CLOEXEC)
|
||||
dirs = sorted({os.path.dirname(f) for f in files if os.path.isdir(os.path.dirname(f))})
|
||||
if fd >= 0 and dirs and all(libc.inotify_add_watch(fd, d.encode(), self.MASK) >= 0 for d in dirs):
|
||||
self.fd = fd
|
||||
elif fd >= 0:
|
||||
os.close(fd)
|
||||
except (OSError, AttributeError):
|
||||
self.fd = -1
|
||||
self.stamp = self.snapshot()
|
||||
|
||||
def snapshot(self):
|
||||
stamp = []
|
||||
for f in self.files:
|
||||
for p in (f, os.path.dirname(f)):
|
||||
try:
|
||||
stamp.append(os.stat(p).st_mtime_ns)
|
||||
except OSError:
|
||||
stamp.append(0)
|
||||
return stamp
|
||||
|
||||
def fileno(self):
|
||||
return self.fd
|
||||
|
||||
def changed(self):
|
||||
if self.fd < 0:
|
||||
stamp = self.snapshot()
|
||||
moved, self.stamp = stamp != self.stamp, stamp
|
||||
return moved
|
||||
names = set()
|
||||
try:
|
||||
while True:
|
||||
data = os.read(self.fd, 65536)
|
||||
if not data:
|
||||
break
|
||||
at = 0
|
||||
while at + 16 <= len(data):
|
||||
_, _, _, size = struct.unpack_from("iIII", data, at)
|
||||
names.add(data[at + 16:at + 16 + size].split(b"\0", 1)[0].decode("utf-8", "replace"))
|
||||
at += 16 + size
|
||||
except BlockingIOError:
|
||||
pass
|
||||
wanted = {os.path.basename(f) for f in self.files}
|
||||
return any(n in wanted or n.startswith("appmanifest_") for n in names)
|
||||
|
||||
|
||||
class Helper:
|
||||
def __init__(self, steam_root, port):
|
||||
self.steam_root = steam_root
|
||||
self.port = port
|
||||
self.page = None
|
||||
self.known = set()
|
||||
self.installed = None
|
||||
self.fex_asked = set()
|
||||
|
||||
def attach(self):
|
||||
path = shared_context(self.port)
|
||||
if path is None:
|
||||
raise LookupError("no SharedJSContext yet")
|
||||
page = Page(self.port, path)
|
||||
try:
|
||||
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})
|
||||
page.compat("get(0)")
|
||||
except Exception:
|
||||
page.ws.close()
|
||||
raise
|
||||
self.page = page
|
||||
return True
|
||||
|
||||
def reconcile(self):
|
||||
page = self.page
|
||||
with COMPAT["locked"]():
|
||||
state_file = COMPAT["state_path"]("state.json")
|
||||
state = COMPAT["read_json"](state_file)
|
||||
request = COMPAT["read_json"](COMPAT["state_path"]("request.json"))
|
||||
catalog = COMPAT["tool_catalog"](self.steam_root)
|
||||
top = page.compat("get(0)")
|
||||
self.known = set(top["tools"])
|
||||
live = [t for t in catalog if t["name"] in self.known]
|
||||
wanted = COMPAT["requested_tool"](request, catalog)
|
||||
newer = isinstance(request.get("seq"), int) and request["seq"] > int(state.get("applied", 0) or 0)
|
||||
waiting = newer and wanted is not None and wanted not in self.known
|
||||
default, state = COMPAT["choose_default"](top["selected"], state, request, live, apply_request=not waiting)
|
||||
installed = COMPAT["installed_apps"](self.steam_root)
|
||||
self.installed = installed
|
||||
picks = COMPAT["valve_picks"](self.steam_root)
|
||||
apps = sorted(set(installed) | set(picks) | set(state.get("auto", {})), key=COMPAT["app_order"])
|
||||
current = dict(page.compat("many(%s)" % json.dumps(apps)) or {})
|
||||
current["0"] = top["selected"]
|
||||
native = COMPAT["native_targets"](self.steam_root, installed)
|
||||
changes, auto = COMPAT["plan_mapping"](current, installed, [t["name"] for t in live], default, COMPAT["followers"](state, current), native, picks)
|
||||
for app, tool in sorted(changes.items(), key=lambda item: COMPAT["app_order"](item[0])):
|
||||
page.compat("set(%d, %s)" % (int(app), json.dumps(tool)))
|
||||
say("%s -> %s" % ("default" if app == "0" else "app %s" % app, tool))
|
||||
state.update(auto=auto, tools=catalog, live=True)
|
||||
if waiting:
|
||||
state["pending"] = wanted
|
||||
say("%s is new to the running client; it applies when Steam next starts" % wanted)
|
||||
else:
|
||||
state.pop("pending", None)
|
||||
COMPAT["write_json"](state_file, state)
|
||||
if native or os.path.exists(COMPAT["fex_wanted_marker"]()):
|
||||
for app in COMPAT["request_fex"](self.steam_root, self.fex_asked):
|
||||
say("asked the client to install %s for x86 Linux titles and programs" % app)
|
||||
|
||||
def request_waiting(self):
|
||||
request = COMPAT["read_json"](COMPAT["state_path"]("request.json"))
|
||||
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 serve(self, watcher):
|
||||
with open(COMPAT["state_path"]("live.pid"), "w") as f:
|
||||
f.write("%d\n" % os.getpid())
|
||||
say("attached to the client on port %d" % self.port)
|
||||
self.reconcile()
|
||||
while True:
|
||||
sources = [self.page.ws] + ([watcher] if watcher.fileno() >= 0 else [])
|
||||
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())
|
||||
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.reconcile()
|
||||
|
||||
|
||||
def detach():
|
||||
try:
|
||||
os.unlink(COMPAT["state_path"]("live.pid"))
|
||||
except OSError:
|
||||
pass
|
||||
with COMPAT["locked"]():
|
||||
state_file = COMPAT["state_path"]("state.json")
|
||||
state = COMPAT["read_json"](state_file)
|
||||
if state.get("live"):
|
||||
state["live"] = False
|
||||
COMPAT["write_json"](state_file, state)
|
||||
|
||||
|
||||
def main():
|
||||
steam_root = sys.argv[1]
|
||||
try:
|
||||
port = int(os.environ.get("BL_CDP_PORT", ""))
|
||||
except ValueError:
|
||||
say("no devtools port for this session; the client's mapping is kept through config.vdf")
|
||||
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)
|
||||
failures = 0
|
||||
last = None
|
||||
while True:
|
||||
try:
|
||||
helper.attach()
|
||||
failures = 0
|
||||
last = None
|
||||
helper.serve(watcher)
|
||||
except Exception as e:
|
||||
if helper.page is not None:
|
||||
say("lost the client (%s); reattaching" % e)
|
||||
helper.page.ws.close()
|
||||
helper.page = None
|
||||
detach()
|
||||
elif str(e) != last:
|
||||
say("waiting for the client (%s)" % e)
|
||||
last = str(e)
|
||||
failures += 1
|
||||
time.sleep(min(2 * max(failures, 1), 10))
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
signal.signal(signal.SIGTERM, lambda *_: sys.exit(0))
|
||||
try:
|
||||
sys.exit(main())
|
||||
finally:
|
||||
detach()
|
||||
+4
-4
@@ -239,13 +239,13 @@ def watch(steam_root, listing):
|
||||
status = last_status
|
||||
if pending and pending != requested and not game_running() and downloads_idle(steam_root):
|
||||
requested = pending
|
||||
print("bannerlator-steam-games: restarting the client once to import %s" % pending, flush=True)
|
||||
print("droiddeck-steam-games: restarting the client once to import %s" % pending, flush=True)
|
||||
try:
|
||||
request_restart(steam_root)
|
||||
except (OSError, subprocess.TimeoutExpired) as error:
|
||||
print("bannerlator-steam-games: restart unavailable: %s" % error, flush=True)
|
||||
print("droiddeck-steam-games: restart unavailable: %s" % error, flush=True)
|
||||
if status != last_status:
|
||||
print("bannerlator-steam-games: " + status, flush=True)
|
||||
print("droiddeck-steam-games: " + status, flush=True)
|
||||
last_status = status
|
||||
time.sleep(30)
|
||||
|
||||
@@ -357,7 +357,7 @@ def route(steam_root, acct, games):
|
||||
routes[str(game["appid"])] = appid
|
||||
continue
|
||||
except OSError as error:
|
||||
print(f"bannerlator-steam-games: import unavailable ({error})")
|
||||
print(f"droiddeck-steam-games: import unavailable ({error})")
|
||||
shortcuts.append(game)
|
||||
save_json(Path(acct) / "config/.droiddeck-routes.json", routes)
|
||||
return shortcuts, routes
|
||||
+7
-3
@@ -6,11 +6,15 @@ cdn=https://client-update.fastly.steamstatic.com
|
||||
steam_channel=${BL_STEAM_CHANNEL:-steamdeck_publicbeta}
|
||||
case "$steam_channel" in
|
||||
publicbeta|steamdeck_publicbeta) ;;
|
||||
*) echo "bannerlator-steam-install: unsupported Steam channel: $steam_channel" >&2; exit 1 ;;
|
||||
*) echo "droiddeck-steam-install: unsupported Steam channel: $steam_channel" >&2; exit 1 ;;
|
||||
esac
|
||||
manifest=steam_client_${steam_channel}_linuxarm64
|
||||
steam_root=${XDG_DATA_HOME:-$HOME/.local/share}/Steam
|
||||
stamp=$steam_root/package/bannerlator-installed
|
||||
stamp=$steam_root/package/droiddeck-installed
|
||||
legacy_stamp=$steam_root/package/bannerlator-installed
|
||||
if [ -f "$legacy_stamp" ] && [ ! -f "$stamp" ]; then
|
||||
mv -f "$legacy_stamp" "$stamp" || true
|
||||
fi
|
||||
[ -x "$steam_root/steamrtarm64/steam" ] && [ -f "$stamp" ] && exit 0
|
||||
|
||||
work=$(mktemp -d)
|
||||
@@ -24,7 +28,7 @@ awk -F'"' '
|
||||
$2 == "sha2" { sha[block] = $4 }
|
||||
END { for (b in file) if (b ~ /_all$/ || b ~ /_linuxarm64_linuxarm64$/) print b, file[b], sha[b] }
|
||||
' "$work/manifest" | sort > "$work/parts"
|
||||
[ -s "$work/parts" ] || { echo "bannerlator-steam-install: no client components in $manifest" >&2; exit 1; }
|
||||
[ -s "$work/parts" ] || { echo "droiddeck-steam-install: no client components in $manifest" >&2; exit 1; }
|
||||
total=$(grep -c . "$work/parts" 2>/dev/null || echo 0)
|
||||
|
||||
mkdir -p "$steam_root/package"
|
||||
+9
-9
@@ -1,12 +1,12 @@
|
||||
#!/bin/bash
|
||||
# Starts the Steam client from inside a session (the desktop's menu entries and the per-game
|
||||
# launchers bannerlator-desktop-games writes):
|
||||
# bannerlator-steam-launch desktop [appid|steam-url] Steam's desktop UI, optionally a game
|
||||
# bannerlator-steam-launch bigpicture [appid|steam-url] Big Picture
|
||||
# launchers droiddeck-desktop-games writes):
|
||||
# droiddeck-steam-launch desktop [appid|steam-url] Steam's desktop UI, optionally a game
|
||||
# droiddeck-steam-launch bigpicture [appid|steam-url] Big Picture
|
||||
#
|
||||
# On a desktop that draws with the GPU (labwc on vulkan or gles2 - the default since the GPU
|
||||
# desktop) the client runs right there: a window on the desktop, through the desktop's Xwayland,
|
||||
# with the same set-up a Steam session gives it (bannerlator-session steam, minus gamescope), and
|
||||
# with the same set-up a Steam session gives it (droiddeck-session steam, minus gamescope), and
|
||||
# its games open in windows of their own. A client already running there gets the request instead
|
||||
# of a second one being started.
|
||||
#
|
||||
@@ -35,24 +35,24 @@ if [ "${BL_DESKTOP:-}" = 1 ] && [ -n "${WLR_RENDERER:-}" ] && [ "$WLR_RENDERER"
|
||||
# One client at a time: the running one takes the request (a second start hands its command
|
||||
# line over and exits). No game asked for = switch it to the UI that was clicked.
|
||||
[ -n "$url" ] || { [ "$ui" = bigpicture ] && url=steam://open/bigpicture || url=steam://open/main; }
|
||||
echo "bannerlator-steam-launch: the client is running on the desktop; handing it $url" | tee -a "$log"
|
||||
echo "droiddeck-steam-launch: the client is running on the desktop; handing it $url" | tee -a "$log"
|
||||
exec "$client" "$url"
|
||||
fi
|
||||
echo "bannerlator-steam-launch: starting the Steam client on the desktop ($ui${url:+, $url}); log: $log"
|
||||
echo "droiddeck-steam-launch: starting the Steam client on the desktop ($ui${url:+, $url}); log: $log"
|
||||
# BL_INSIDE: the session script's Steam start-up without gamescope in front of it. The desktop UI
|
||||
# unless Big Picture was asked for; never Deck mode (its Quick Access Menu needs gamescope).
|
||||
export BL_INSIDE=1 BL_STEAMDECK=0
|
||||
if [ "$ui" = desktop ]; then export BL_STEAM_UI=desktop; else unset BL_STEAM_UI; fi
|
||||
setsid /usr/local/bin/bannerlator-session steam ${url:+"$url"} >>"$log" 2>&1 < /dev/null &
|
||||
setsid /usr/local/bin/droiddeck-session steam ${url:+"$url"} >>"$log" 2>&1 < /dev/null &
|
||||
exit 0
|
||||
fi
|
||||
|
||||
# The software desktop, or outside the desktop: ask the app for a Steam session.
|
||||
dir=${BL_LAUNCH_DIR:-}
|
||||
if [ -z "$dir" ] || [ ! -d "$dir" ]; then
|
||||
echo "bannerlator-steam-launch: not inside a DroidDeck session (BL_LAUNCH_DIR unset)" >&2
|
||||
echo "droiddeck-steam-launch: not inside a DroidDeck session (BL_LAUNCH_DIR unset)" >&2
|
||||
exit 69
|
||||
fi
|
||||
# Written whole, then renamed: the app reads it on close, never half-written.
|
||||
printf 'ui=%s\nurl=%s\n' "$ui" "$url" > "$dir/steam-launch.tmp" && mv -f "$dir/steam-launch.tmp" "$dir/steam-launch"
|
||||
echo "bannerlator-steam-launch: asked the app for Steam ($ui${url:+, $url})"
|
||||
echo "droiddeck-steam-launch: asked the app for Steam ($ui${url:+, $url})"
|
||||
+6
-6
@@ -2,7 +2,7 @@
|
||||
# Registers the card the app installs to (bound at /mnt/droiddeck-sd) as a library folder of the
|
||||
# native Steam client, so they show as installed there instead of being downloaded a second time.
|
||||
#
|
||||
# bannerlator-steam-library <steam root>
|
||||
# droiddeck-steam-library <steam root>
|
||||
#
|
||||
# Ported from WinNative's gamescope runtime (GPL-3.0).
|
||||
import os
|
||||
@@ -61,7 +61,7 @@ def register(steam_root, library, label):
|
||||
os.makedirs(steamapps_dir, exist_ok=True)
|
||||
with open(path, "w", encoding="utf-8") as f:
|
||||
f.write(text)
|
||||
print("bannerlator-steam-library: registered %s with %d game(s)" % (library, len(apps)))
|
||||
print("droiddeck-steam-library: registered %s with %d game(s)" % (library, len(apps)))
|
||||
return len(apps)
|
||||
|
||||
|
||||
@@ -85,7 +85,7 @@ def rename(steam_root, old, new):
|
||||
return
|
||||
with open(path, "w", encoding="utf-8") as f:
|
||||
f.write(old_path.sub(lambda m: m.group(1) + new + m.group(2), text))
|
||||
print("bannerlator-steam-library: moved %s to %s" % (old, new))
|
||||
print("droiddeck-steam-library: moved %s to %s" % (old, new))
|
||||
|
||||
|
||||
def forget(steam_root, library):
|
||||
@@ -115,7 +115,7 @@ def forget(steam_root, library):
|
||||
if text != "\n".join(lines):
|
||||
with open(path, "w", encoding="utf-8") as f:
|
||||
f.write(text)
|
||||
print("bannerlator-steam-library: forgot %s" % library)
|
||||
print("droiddeck-steam-library: forgot %s" % library)
|
||||
|
||||
|
||||
def relabel(steam_root, target, label):
|
||||
@@ -151,7 +151,7 @@ def relabel(steam_root, target, label):
|
||||
if changed:
|
||||
with open(path, "w", encoding="utf-8") as f:
|
||||
f.write("\n".join(out))
|
||||
print("bannerlator-steam-library: labelled %s %r" % (target, label))
|
||||
print("droiddeck-steam-library: labelled %s %r" % (target, label))
|
||||
# A library also carries its own libraryfolder.vdf, and the client takes the label from there
|
||||
# back into the list above - so editing the list alone is undone on the next start. The
|
||||
# client's own library has no such file, which is why that one kept the new name and the card
|
||||
@@ -165,7 +165,7 @@ def relabel(steam_root, target, label):
|
||||
if new != text:
|
||||
with open(marker, "w", encoding="utf-8") as f:
|
||||
f.write(new)
|
||||
print("bannerlator-steam-library: labelled %s in its own marker too" % target)
|
||||
print("droiddeck-steam-library: labelled %s in its own marker too" % target)
|
||||
|
||||
|
||||
def main():
|
||||
+2
-2
@@ -1,7 +1,7 @@
|
||||
#!/bin/bash
|
||||
# `steam` on the desktop. The client writes a menu entry per installed game that runs
|
||||
# `steam steam://rungameid/<id>`, and its own launchers say `steam`. On the desktop that goes
|
||||
# through bannerlator-steam-launch - which runs the client on the desktop itself when it draws with
|
||||
# through droiddeck-steam-launch - which runs the client on the desktop itself when it draws with
|
||||
# the GPU, hands the URL to a client already running there, and asks the app for a Steam session
|
||||
# on a software desktop. Anywhere else it is the client itself.
|
||||
set -u
|
||||
@@ -14,6 +14,6 @@ if [ "${BL_DESKTOP:-}" = 1 ]; then
|
||||
-gamepadui|-bigpicture) ui=bigpicture ;;
|
||||
esac
|
||||
done
|
||||
exec /usr/local/bin/bannerlator-steam-launch "$ui" ${url:+"$url"}
|
||||
exec /usr/local/bin/droiddeck-steam-launch "$ui" ${url:+"$url"}
|
||||
fi
|
||||
exec "${HOME:-/root}/.local/share/Steam/steamrtarm64/steam" "$@"
|
||||
+14
-13
@@ -1,7 +1,7 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Import added games while Steam is closed, preserving user-created shortcuts.
|
||||
|
||||
Usage: bannerlator-steam-shortcuts <steam_root> <added-games.json>
|
||||
Usage: droiddeck-steam-shortcuts <steam_root> <added-games.json>
|
||||
"""
|
||||
import importlib.machinery
|
||||
import importlib.util
|
||||
@@ -163,7 +163,7 @@ def install_art(acct, games):
|
||||
os.replace(dst + ".tmp", dst)
|
||||
copied += 1
|
||||
except OSError as e:
|
||||
print("bannerlator-steam-shortcuts: could not copy art %s (%s)" % (name, e))
|
||||
print("droiddeck-steam-shortcuts: could not copy art %s (%s)" % (name, e))
|
||||
for name in list(manifest):
|
||||
if name not in wanted:
|
||||
try:
|
||||
@@ -173,7 +173,7 @@ def install_art(acct, games):
|
||||
with open(manifest_path, "w", encoding="utf-8") as f:
|
||||
json.dump(wanted, f)
|
||||
if copied:
|
||||
print("bannerlator-steam-shortcuts: %d piece(s) of art placed" % copied)
|
||||
print("droiddeck-steam-shortcuts: %d piece(s) of art placed" % copied)
|
||||
|
||||
|
||||
def main():
|
||||
@@ -185,11 +185,11 @@ def main():
|
||||
with open(listing, encoding="utf-8") as f:
|
||||
games = json.load(f)
|
||||
except (OSError, ValueError) as e:
|
||||
print("bannerlator-steam-shortcuts: no list (%s)" % e)
|
||||
print("droiddeck-steam-shortcuts: no list (%s)" % e)
|
||||
return 0
|
||||
acct = account_dir(steam_root)
|
||||
if not acct:
|
||||
print("bannerlator-steam-shortcuts: no signed-in account yet; nothing written")
|
||||
print("droiddeck-steam-shortcuts: no signed-in account yet; nothing written")
|
||||
return 0
|
||||
config = os.path.join(acct, "config")
|
||||
os.makedirs(config, exist_ok=True)
|
||||
@@ -200,9 +200,9 @@ def main():
|
||||
with open(path, "rb") as f:
|
||||
existing = parse(f.read()).get("shortcuts", {})
|
||||
except (ValueError, IndexError, struct.error) as e:
|
||||
print("bannerlator-steam-shortcuts: could not read the existing file (%s); keeping it unchanged" % e)
|
||||
print("droiddeck-steam-shortcuts: could not read the existing file (%s); keeping it unchanged" % e)
|
||||
return 1
|
||||
helper = os.path.join(os.path.dirname(os.path.abspath(__file__)), "bannerlator-steam-games")
|
||||
helper = os.path.join(os.path.dirname(os.path.abspath(__file__)), "droiddeck-steam-games")
|
||||
loader = importlib.machinery.SourceFileLoader("steam_games", helper)
|
||||
spec = importlib.util.spec_from_loader(loader.name, loader)
|
||||
routing = importlib.util.module_from_spec(spec)
|
||||
@@ -225,25 +225,26 @@ def main():
|
||||
entry["LaunchOptions"] = previous["LaunchOptions"]
|
||||
ours.append(entry)
|
||||
entries = {str(i): v for i, v in enumerate(kept + ours)}
|
||||
tmp = path + ".bannerlator"
|
||||
tmp = path + ".droiddeck"
|
||||
with open(tmp, "wb") as f:
|
||||
f.write(write({"shortcuts": entries}))
|
||||
os.replace(tmp, path)
|
||||
print("bannerlator-steam-shortcuts: %d added game(s) written, %d of the client's own kept" % (len(ours), len(kept)))
|
||||
print("droiddeck-steam-shortcuts: %d added game(s) written, %d of the client's own kept" % (len(ours), len(kept)))
|
||||
install_art(acct, [g for g in games if g.get("exe") and g.get("name")])
|
||||
# Each added game runs under the ARM64 Proton: the compat registrar's own mapping writer.
|
||||
try:
|
||||
# No .py suffix on the registrar, so the loader has to be named.
|
||||
compat_path = "/usr/local/bin/bannerlator-steam-compat"
|
||||
compat_path = "/usr/local/bin/steam-compatibility"
|
||||
spec = importlib.util.spec_from_file_location("compat", compat_path, loader=importlib.machinery.SourceFileLoader("compat", compat_path))
|
||||
compat = importlib.util.module_from_spec(spec)
|
||||
spec.loader.exec_module(compat)
|
||||
cfg = os.path.join(steam_root, "config", "config.vdf")
|
||||
if os.path.isfile(cfg) and (ours or routes):
|
||||
compat.register_default(cfg, apps=[str(int(g["appid"]) & 0xFFFFFFFF) for g in games if g.get("exe")] + [str(appid) for appid in set(routes.values())])
|
||||
print("bannerlator-steam-shortcuts: mapped them to %s" % compat.TOOL)
|
||||
compat.register_default(cfg, apps=[str(int(g["appid"]) & 0xFFFFFFFF) for g in games if g.get("exe")] + [str(appid) for appid in set(routes.values())],
|
||||
protect=compat.adopt_extras(os.path.join(steam_root, "compatibilitytools.d")))
|
||||
print("droiddeck-steam-shortcuts: mapped them to %s" % compat.TOOL)
|
||||
except Exception as e: # noqa: BLE001 - the games still show; the client falls back to the default tool
|
||||
print("bannerlator-steam-shortcuts: compat mapping skipped (%s)" % e)
|
||||
print("droiddeck-steam-shortcuts: compat mapping skipped (%s)" % e)
|
||||
return 0
|
||||
|
||||
|
||||
File renamed without changes.
+1153
File diff suppressed because it is too large.
Load diff
@@ -0,0 +1,653 @@
|
||||
/* droiddeck-fsync: futex_waitv(2) in userspace, so Proton's own fsync runs where the app sandbox refuses the syscall.
|
||||
* Credit: fsync, the futex-based synchronization in Proton, by Elizabeth Figura and Paul Gofman;
|
||||
* futex_waitv(2) by André Almeida. */
|
||||
#define _GNU_SOURCE
|
||||
#include <dlfcn.h>
|
||||
#include <errno.h>
|
||||
#include <fcntl.h>
|
||||
#include <linux/futex.h>
|
||||
#include <pthread.h>
|
||||
#include <signal.h>
|
||||
#include <stdlib.h>
|
||||
#include <stdint.h>
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <sys/mman.h>
|
||||
#include <sys/stat.h>
|
||||
#include <sys/syscall.h>
|
||||
#include <time.h>
|
||||
#include <unistd.h>
|
||||
|
||||
#ifndef SYS_futex_waitv
|
||||
#define SYS_futex_waitv 449
|
||||
#endif
|
||||
|
||||
#define FS_SLOTS 2048u
|
||||
#define FS_WORDS (FS_SLOTS / 64u)
|
||||
#define FS_BUCKETS 4096u
|
||||
#define FS_KEYS 128u
|
||||
#define FS_NOKEY 0xffffffffu
|
||||
#define FS_SIZE32 2u
|
||||
#define FS_PRIVATE 128u
|
||||
#define FS_MAGIC 0x434e595346444444ull
|
||||
#define FS_SWEEP_NS 1000000000ull
|
||||
#define FS_POLL_NS 500000l
|
||||
#define FS_NAP_MIN 10000000ull
|
||||
#define FS_NAP_MAX 1000000000ull
|
||||
#define FS_HEAD_SIZE 4096ul
|
||||
|
||||
struct fs_waitv {
|
||||
uint64_t val;
|
||||
uint64_t uaddr;
|
||||
uint32_t flags;
|
||||
uint32_t reserved;
|
||||
};
|
||||
|
||||
struct fs_bucket {
|
||||
uint64_t bits[FS_WORDS];
|
||||
};
|
||||
|
||||
struct fs_slot {
|
||||
uint32_t futex;
|
||||
uint32_t count;
|
||||
uint64_t owner;
|
||||
uint32_t keys[FS_KEYS];
|
||||
};
|
||||
|
||||
struct fs_head {
|
||||
uint64_t magic;
|
||||
uint32_t sweeper;
|
||||
uint32_t pad;
|
||||
uint64_t sweep_at;
|
||||
uint64_t used[FS_WORDS];
|
||||
};
|
||||
|
||||
#define FS_BUCKET_OFF FS_HEAD_SIZE
|
||||
#define FS_SLOT_OFF (FS_BUCKET_OFF + (size_t)FS_BUCKETS * sizeof(struct fs_bucket))
|
||||
#define FS_REGION (FS_SLOT_OFF + (size_t)FS_SLOTS * sizeof(struct fs_slot))
|
||||
|
||||
_Static_assert(sizeof(struct fs_head) <= FS_HEAD_SIZE, "fsync registry head");
|
||||
|
||||
struct fs_range {
|
||||
uintptr_t lo;
|
||||
uintptr_t hi;
|
||||
uint64_t off;
|
||||
};
|
||||
|
||||
struct fs_map {
|
||||
uint32_t n;
|
||||
struct fs_range r[];
|
||||
};
|
||||
|
||||
static int fs_state = -1;
|
||||
static char *fs_reg;
|
||||
static int fs_fd = -1;
|
||||
static struct fs_map *fs_cur;
|
||||
static uint32_t fs_pid;
|
||||
static pthread_mutex_t fs_mx = PTHREAD_MUTEX_INITIALIZER;
|
||||
static pthread_key_t fs_key;
|
||||
static pthread_once_t fs_once = PTHREAD_ONCE_INIT;
|
||||
static __thread int32_t fs_tslot = -1;
|
||||
static __thread int fs_busy;
|
||||
static __thread uint32_t fs_tid;
|
||||
static __thread uint32_t fs_nap_key;
|
||||
static __thread uint32_t fs_nap_n;
|
||||
static __thread uint64_t fs_nap_ns;
|
||||
static __thread sigset_t fs_fork_mask;
|
||||
|
||||
static long (*fs_real_syscall)(long, ...);
|
||||
static int (*fs_real_shm_open)(const char *, int, mode_t);
|
||||
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);
|
||||
|
||||
static int fs_on(void) {
|
||||
if (fs_state < 0) {
|
||||
const char *e = getenv("BL_FSYNC");
|
||||
fs_state = e && e[0] == '1';
|
||||
}
|
||||
return fs_state;
|
||||
}
|
||||
|
||||
static long fs_sys(long n, long a, long b, long c, long d, long e, long f) {
|
||||
if (!fs_real_syscall) fs_real_syscall = (long (*)(long, ...))dlsym(RTLD_NEXT, "syscall");
|
||||
return fs_real_syscall(n, a, b, c, d, e, f);
|
||||
}
|
||||
|
||||
static void *fs_anon(size_t size) {
|
||||
if (!fs_real_mmap) fs_real_mmap = (void *(*)(void *, size_t, int, int, int, off_t))dlsym(RTLD_NEXT, "mmap");
|
||||
return fs_real_mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
|
||||
}
|
||||
|
||||
static uint32_t fs_self(void) {
|
||||
if (!fs_tid) fs_tid = (uint32_t)fs_sys(SYS_gettid, 0, 0, 0, 0, 0, 0);
|
||||
return fs_tid;
|
||||
}
|
||||
|
||||
static uint32_t fs_getpid(void) {
|
||||
if (!fs_pid) fs_pid = (uint32_t)getpid();
|
||||
return fs_pid;
|
||||
}
|
||||
|
||||
static uint64_t fs_now(void) {
|
||||
struct timespec ts;
|
||||
clock_gettime(CLOCK_MONOTONIC, &ts);
|
||||
return (uint64_t)ts.tv_sec * 1000000000ull + (uint64_t)ts.tv_nsec;
|
||||
}
|
||||
|
||||
static int fs_dead(uint32_t pid, uint32_t tid) {
|
||||
int saved = errno, dead;
|
||||
dead = pid && fs_sys(SYS_tgkill, pid, tid, 0, 0, 0, 0) == -1 && errno == ESRCH;
|
||||
errno = saved;
|
||||
return dead;
|
||||
}
|
||||
|
||||
static uint64_t fs_owner(void) {
|
||||
return (uint64_t)fs_getpid() << 32 | fs_self();
|
||||
}
|
||||
|
||||
static void fs_block(sigset_t *old) {
|
||||
sigset_t all;
|
||||
sigfillset(&all);
|
||||
pthread_sigmask(SIG_SETMASK, &all, old);
|
||||
}
|
||||
|
||||
static inline struct fs_head *fs_head(void) {
|
||||
return (struct fs_head *)fs_reg;
|
||||
}
|
||||
|
||||
static inline struct fs_bucket *fs_bucket(uint32_t key) {
|
||||
return (struct fs_bucket *)(fs_reg + FS_BUCKET_OFF) + ((key >> 4) & (FS_BUCKETS - 1));
|
||||
}
|
||||
|
||||
static inline struct fs_slot *fs_slot(uint32_t s) {
|
||||
return (struct fs_slot *)(fs_reg + FS_SLOT_OFF) + s;
|
||||
}
|
||||
|
||||
static int fs_key_of(uint64_t addr, uint32_t *key) {
|
||||
struct fs_map *m = __atomic_load_n(&fs_cur, __ATOMIC_ACQUIRE);
|
||||
uint32_t lo = 0, hi;
|
||||
if (!m) return 0;
|
||||
hi = m->n;
|
||||
while (lo < hi) {
|
||||
uint32_t mid = (lo + hi) / 2;
|
||||
if (addr < m->r[mid].lo) {
|
||||
hi = mid;
|
||||
} else if (addr >= m->r[mid].hi) {
|
||||
lo = mid + 1;
|
||||
} else {
|
||||
uint64_t k = m->r[mid].off + (addr - m->r[mid].lo);
|
||||
if (k >= FS_NOKEY) return 0;
|
||||
*key = (uint32_t)k;
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int fs_overlaps(uintptr_t lo, uintptr_t hi) {
|
||||
struct fs_map *m = __atomic_load_n(&fs_cur, __ATOMIC_ACQUIRE);
|
||||
if (!m) return 0;
|
||||
for (uint32_t i = 0; i < m->n; i++)
|
||||
if (m->r[i].lo < hi && m->r[i].hi > lo) return 1;
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void fs_rebuild_locked(uintptr_t lo, uintptr_t hi, const struct fs_range *add) {
|
||||
struct fs_map *old, *m;
|
||||
uint32_t n, k = 0;
|
||||
int added = 0;
|
||||
old = fs_cur;
|
||||
n = old ? old->n : 0;
|
||||
m = fs_anon(sizeof(*m) + (n + 1) * sizeof(struct fs_range));
|
||||
if (m == MAP_FAILED) return;
|
||||
for (uint32_t i = 0; i < n; i++) {
|
||||
const struct fs_range *r = &old->r[i];
|
||||
if (r->lo < hi && r->hi > lo) continue;
|
||||
if (add && !added && add->lo < r->lo) {
|
||||
m->r[k++] = *add;
|
||||
added = 1;
|
||||
}
|
||||
m->r[k++] = *r;
|
||||
}
|
||||
if (add && !added) m->r[k++] = *add;
|
||||
m->n = k;
|
||||
__atomic_store_n(&fs_cur, m, __ATOMIC_RELEASE);
|
||||
}
|
||||
|
||||
static void fs_rebuild(uintptr_t lo, uintptr_t hi, const struct fs_range *add) {
|
||||
sigset_t old;
|
||||
fs_block(&old);
|
||||
pthread_mutex_lock(&fs_mx);
|
||||
fs_rebuild_locked(lo, hi, add);
|
||||
pthread_mutex_unlock(&fs_mx);
|
||||
pthread_sigmask(SIG_SETMASK, &old, NULL);
|
||||
}
|
||||
|
||||
static void fs_track(void *p, size_t len, int flags, int fd, off_t off) {
|
||||
uintptr_t lo = (uintptr_t)p, hi = lo + len;
|
||||
int saved = errno;
|
||||
if (fs_fd >= 0 && fd == fs_fd && (flags & MAP_SHARED) && off >= 0) {
|
||||
struct fs_range r = {lo, hi, (uint64_t)off};
|
||||
fs_rebuild(lo, hi, &r);
|
||||
} else if (fs_overlaps(lo, hi)) {
|
||||
fs_rebuild(lo, hi, NULL);
|
||||
}
|
||||
errno = saved;
|
||||
}
|
||||
|
||||
static void fs_unregister(uint32_t s, const uint32_t *keys, uint32_t n) {
|
||||
uint64_t bit = 1ull << (s & 63);
|
||||
for (uint32_t i = 0; i < n; i++) {
|
||||
struct fs_bucket *b;
|
||||
if (keys[i] == FS_NOKEY) continue;
|
||||
b = fs_bucket(keys[i]);
|
||||
__atomic_and_fetch(&b->bits[s >> 6], ~bit, __ATOMIC_SEQ_CST);
|
||||
}
|
||||
}
|
||||
|
||||
static void fs_release(uint32_t s, uint64_t owner) {
|
||||
struct fs_slot *sl = fs_slot(s);
|
||||
uint32_t n, keys[FS_KEYS];
|
||||
if (!owner || !__atomic_compare_exchange_n(&sl->owner, &owner, 0, 0, __ATOMIC_ACQ_REL, __ATOMIC_RELAXED)) return;
|
||||
n = __atomic_load_n(&sl->count, __ATOMIC_RELAXED);
|
||||
if (n > FS_KEYS) n = FS_KEYS;
|
||||
for (uint32_t i = 0; i < n; i++) keys[i] = __atomic_load_n(&sl->keys[i], __ATOMIC_RELAXED);
|
||||
fs_unregister(s, keys, n);
|
||||
__atomic_store_n(&sl->count, 0, __ATOMIC_RELAXED);
|
||||
__atomic_and_fetch(&fs_head()->used[s >> 6], ~(1ull << (s & 63)), __ATOMIC_RELEASE);
|
||||
}
|
||||
|
||||
static void fs_sweep(int force) {
|
||||
struct fs_head *h = fs_head();
|
||||
uint64_t now = fs_now();
|
||||
uint32_t me = fs_getpid(), cur = 0;
|
||||
if (!force && now < __atomic_load_n(&h->sweep_at, __ATOMIC_RELAXED)) return;
|
||||
if (!__atomic_compare_exchange_n(&h->sweeper, &cur, me, 0, __ATOMIC_ACQUIRE, __ATOMIC_RELAXED)) {
|
||||
if (!fs_dead(cur, cur) || !__atomic_compare_exchange_n(&h->sweeper, &cur, me, 0, __ATOMIC_ACQUIRE, __ATOMIC_RELAXED))
|
||||
return;
|
||||
}
|
||||
__atomic_store_n(&h->sweep_at, now + FS_SWEEP_NS, __ATOMIC_RELAXED);
|
||||
for (uint32_t w = 0; w < FS_WORDS; w++) {
|
||||
uint64_t u = __atomic_load_n(&h->used[w], __ATOMIC_ACQUIRE);
|
||||
while (u) {
|
||||
uint32_t s = w * 64 + (uint32_t)__builtin_ctzll(u);
|
||||
struct fs_slot *sl = fs_slot(s);
|
||||
u &= u - 1;
|
||||
uint64_t owner = __atomic_load_n(&sl->owner, __ATOMIC_ACQUIRE);
|
||||
if (fs_dead((uint32_t)(owner >> 32), (uint32_t)owner)) fs_release(s, owner);
|
||||
}
|
||||
}
|
||||
__atomic_store_n(&h->sweeper, 0, __ATOMIC_RELEASE);
|
||||
}
|
||||
|
||||
static int32_t fs_alloc(void) {
|
||||
struct fs_head *h = fs_head();
|
||||
fs_sweep(0);
|
||||
for (int pass = 0; pass < 2; pass++) {
|
||||
for (uint32_t w = 0; w < FS_WORDS; w++) {
|
||||
uint64_t u = __atomic_load_n(&h->used[w], __ATOMIC_RELAXED);
|
||||
while (~u) {
|
||||
uint32_t b = (uint32_t)__builtin_ctzll(~u);
|
||||
if (__atomic_compare_exchange_n(&h->used[w], &u, u | (1ull << b), 0, __ATOMIC_ACQ_REL, __ATOMIC_RELAXED)) {
|
||||
uint32_t s = w * 64 + b;
|
||||
struct fs_slot *sl = fs_slot(s);
|
||||
__atomic_store_n(&sl->count, 0, __ATOMIC_RELAXED);
|
||||
__atomic_store_n(&sl->owner, fs_owner(), __ATOMIC_RELEASE);
|
||||
return (int32_t)s;
|
||||
}
|
||||
}
|
||||
}
|
||||
fs_sweep(1);
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
|
||||
static void fs_thread_gone(void *p) {
|
||||
uint32_t s = (uint32_t)((uintptr_t)p - 1);
|
||||
if (fs_reg && s < FS_SLOTS && fs_tslot == (int32_t)s) {
|
||||
fs_tslot = -1;
|
||||
fs_busy = 0;
|
||||
fs_release(s, fs_owner());
|
||||
}
|
||||
}
|
||||
|
||||
static void fs_key_init(void) {
|
||||
pthread_key_create(&fs_key, fs_thread_gone);
|
||||
}
|
||||
|
||||
static void fs_fork_prepare(void) {
|
||||
fs_block(&fs_fork_mask);
|
||||
pthread_mutex_lock(&fs_mx);
|
||||
}
|
||||
|
||||
static void fs_fork_parent(void) {
|
||||
pthread_mutex_unlock(&fs_mx);
|
||||
pthread_sigmask(SIG_SETMASK, &fs_fork_mask, NULL);
|
||||
}
|
||||
|
||||
static void fs_child(void) {
|
||||
pthread_mutex_init(&fs_mx, NULL);
|
||||
pthread_sigmask(SIG_SETMASK, &fs_fork_mask, NULL);
|
||||
fs_pid = 0;
|
||||
fs_tid = 0;
|
||||
fs_busy = 0;
|
||||
if (fs_tslot >= 0) {
|
||||
fs_tslot = -1;
|
||||
pthread_setspecific(fs_key, NULL);
|
||||
}
|
||||
}
|
||||
|
||||
__attribute__((constructor)) static void fs_init(void) {
|
||||
if (!fs_real_mmap) fs_real_mmap = (void *(*)(void *, size_t, int, int, int, off_t))dlsym(RTLD_NEXT, "mmap");
|
||||
if (!fs_real_mmap64) fs_real_mmap64 = (void *(*)(void *, size_t, int, int, int, off64_t))dlsym(RTLD_NEXT, "mmap64");
|
||||
if (!fs_real_munmap) fs_real_munmap = (int (*)(void *, size_t))dlsym(RTLD_NEXT, "munmap");
|
||||
if (fs_on()) pthread_atfork(fs_fork_prepare, fs_fork_parent, fs_child);
|
||||
}
|
||||
|
||||
static int32_t fs_take(int *temp) {
|
||||
if (fs_busy) {
|
||||
*temp = 1;
|
||||
return fs_alloc();
|
||||
}
|
||||
*temp = 0;
|
||||
fs_busy = 1;
|
||||
__atomic_signal_fence(__ATOMIC_SEQ_CST);
|
||||
if (fs_tslot < 0) {
|
||||
int32_t s = fs_alloc();
|
||||
if (s < 0) {
|
||||
fs_busy = 0;
|
||||
return -1;
|
||||
}
|
||||
pthread_once(&fs_once, fs_key_init);
|
||||
pthread_setspecific(fs_key, (void *)(uintptr_t)(s + 1));
|
||||
fs_tslot = s;
|
||||
}
|
||||
return fs_tslot;
|
||||
}
|
||||
|
||||
static void fs_give(int32_t s, int temp) {
|
||||
if (temp) {
|
||||
fs_release((uint32_t)s, fs_owner());
|
||||
} else {
|
||||
__atomic_signal_fence(__ATOMIC_SEQ_CST);
|
||||
fs_busy = 0;
|
||||
}
|
||||
}
|
||||
|
||||
static int fs_changed(const struct fs_waitv *v, uint32_t n) {
|
||||
for (uint32_t i = 0; i < n; i++)
|
||||
if (__atomic_load_n((uint32_t *)(uintptr_t)v[i].uaddr, __ATOMIC_SEQ_CST) != (uint32_t)v[i].val) return (int)i;
|
||||
return -1;
|
||||
}
|
||||
|
||||
static int fs_past(const struct timespec *ts, int clk) {
|
||||
struct timespec now;
|
||||
if (!ts) return 0;
|
||||
clock_gettime(clk, &now);
|
||||
return now.tv_sec > ts->tv_sec || (now.tv_sec == ts->tv_sec && now.tv_nsec >= ts->tv_nsec);
|
||||
}
|
||||
|
||||
static uint64_t fs_clock_ns(int clk) {
|
||||
struct timespec now;
|
||||
clock_gettime(clk, &now);
|
||||
return (uint64_t)now.tv_sec * 1000000000ull + (uint64_t)now.tv_nsec;
|
||||
}
|
||||
|
||||
static uint64_t fs_ts_ns(const struct timespec *ts) {
|
||||
return (uint64_t)ts->tv_sec * 1000000000ull + (uint64_t)ts->tv_nsec;
|
||||
}
|
||||
|
||||
static long fs_poll(const struct fs_waitv *v, uint32_t n, const struct timespec *ts, int clk) {
|
||||
int i = fs_changed(v, n);
|
||||
if (i >= 0) {
|
||||
errno = EAGAIN;
|
||||
return -1;
|
||||
}
|
||||
for (;;) {
|
||||
struct timespec nap = {0, FS_POLL_NS};
|
||||
if (fs_past(ts, clk)) {
|
||||
errno = ETIMEDOUT;
|
||||
return -1;
|
||||
}
|
||||
if (nanosleep(&nap, NULL) == -1 && errno == EINTR) return -1;
|
||||
if ((i = fs_changed(v, n)) >= 0) return i;
|
||||
}
|
||||
}
|
||||
|
||||
static long fs_waitv(const struct fs_waitv *v, uint32_t n, uint32_t flags, const struct timespec *ts, int clk) {
|
||||
uint32_t keys[FS_KEYS];
|
||||
struct fs_slot *sl;
|
||||
struct timespec nap_ts;
|
||||
const struct timespec *until = ts;
|
||||
int temp, err = 0, op, napping = 0, wclk = clk, saved = errno;
|
||||
int32_t s;
|
||||
uint64_t bit, nap;
|
||||
if (!v || !n || n > FS_KEYS || flags || (ts && clk != CLOCK_MONOTONIC && clk != CLOCK_REALTIME)) {
|
||||
errno = EINVAL;
|
||||
return -1;
|
||||
}
|
||||
for (uint32_t i = 0; i < n; i++) {
|
||||
if ((v[i].flags & ~FS_PRIVATE) != FS_SIZE32 || v[i].reserved || (v[i].uaddr & 3)) {
|
||||
errno = EINVAL;
|
||||
return -1;
|
||||
}
|
||||
if ((v[i].flags & FS_PRIVATE) || !fs_key_of(v[i].uaddr, &keys[i])) keys[i] = FS_NOKEY;
|
||||
}
|
||||
if (!fs_reg || (s = fs_take(&temp)) < 0) return fs_poll(v, n, ts, clk);
|
||||
sl = fs_slot((uint32_t)s);
|
||||
bit = 1ull << (s & 63);
|
||||
for (uint32_t i = 0; i < n; i++) __atomic_store_n(&sl->keys[i], keys[i], __ATOMIC_RELAXED);
|
||||
__atomic_store_n(&sl->count, n, __ATOMIC_RELAXED);
|
||||
__atomic_store_n(&sl->futex, 0, __ATOMIC_RELAXED);
|
||||
for (uint32_t i = 0; i < n; i++) {
|
||||
struct fs_bucket *b;
|
||||
if (keys[i] == FS_NOKEY) continue;
|
||||
b = fs_bucket(keys[i]);
|
||||
__atomic_or_fetch(&b->bits[s >> 6], bit, __ATOMIC_SEQ_CST);
|
||||
}
|
||||
__atomic_thread_fence(__ATOMIC_SEQ_CST);
|
||||
if (fs_changed(v, n) >= 0) err = EAGAIN;
|
||||
nap = fs_nap_ns && fs_nap_n == n && fs_nap_key == keys[0] ? fs_nap_ns * 2 : FS_NAP_MIN;
|
||||
if (nap > FS_NAP_MAX) nap = FS_NAP_MAX;
|
||||
if (!ts || fs_ts_ns(ts) > fs_clock_ns(clk) + nap) {
|
||||
uint64_t at = fs_clock_ns(CLOCK_MONOTONIC) + nap;
|
||||
nap_ts.tv_sec = (time_t)(at / 1000000000ull);
|
||||
nap_ts.tv_nsec = (long)(at % 1000000000ull);
|
||||
until = &nap_ts;
|
||||
wclk = CLOCK_MONOTONIC;
|
||||
napping = 1;
|
||||
}
|
||||
op = FUTEX_WAIT_BITSET | (until && wclk == CLOCK_REALTIME ? FUTEX_CLOCK_REALTIME : 0);
|
||||
while (!err && !__atomic_load_n(&sl->futex, __ATOMIC_ACQUIRE)) {
|
||||
if (fs_sys(SYS_futex, (long)&sl->futex, op, 0, (long)until, 0, FUTEX_BITSET_MATCH_ANY) == -1 && errno != EAGAIN
|
||||
&& !__atomic_load_n(&sl->futex, __ATOMIC_ACQUIRE))
|
||||
err = errno;
|
||||
}
|
||||
fs_unregister((uint32_t)s, keys, n);
|
||||
if (err && __atomic_exchange_n(&sl->futex, 1, __ATOMIC_ACQ_REL)) err = 0;
|
||||
fs_give(s, temp);
|
||||
if (err == ETIMEDOUT && napping) {
|
||||
fs_nap_key = keys[0];
|
||||
fs_nap_n = n;
|
||||
fs_nap_ns = nap;
|
||||
errno = EINTR;
|
||||
return -1;
|
||||
}
|
||||
if (err != EINTR) fs_nap_ns = 0;
|
||||
if (err) {
|
||||
errno = err;
|
||||
return -1;
|
||||
}
|
||||
errno = saved;
|
||||
s = fs_changed(v, n);
|
||||
return s < 0 ? 0 : s;
|
||||
}
|
||||
|
||||
static long fs_wake(uint32_t key, int n) {
|
||||
struct fs_bucket *b = fs_bucket(key);
|
||||
long woken = 0;
|
||||
__atomic_thread_fence(__ATOMIC_SEQ_CST);
|
||||
if (n <= 0) return 0;
|
||||
for (uint32_t w = 0; w < FS_WORDS; w++) {
|
||||
uint64_t bits = __atomic_load_n(&b->bits[w], __ATOMIC_SEQ_CST);
|
||||
while (bits) {
|
||||
uint32_t s = w * 64 + (uint32_t)__builtin_ctzll(bits), c;
|
||||
struct fs_slot *sl = fs_slot(s);
|
||||
bits &= bits - 1;
|
||||
c = __atomic_load_n(&sl->count, __ATOMIC_ACQUIRE);
|
||||
if (c > FS_KEYS) c = FS_KEYS;
|
||||
for (uint32_t i = 0; i < c; i++) {
|
||||
if (__atomic_load_n(&sl->keys[i], __ATOMIC_RELAXED) != key) continue;
|
||||
if (!__atomic_exchange_n(&sl->futex, 1, __ATOMIC_SEQ_CST)) {
|
||||
int saved = errno;
|
||||
fs_sys(SYS_futex, (long)&sl->futex, FUTEX_WAKE, 1, 0, 0, 0);
|
||||
errno = saved;
|
||||
if (++woken >= n) return woken;
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
return woken;
|
||||
}
|
||||
|
||||
void bl_fsync_fds_closed(unsigned int first, unsigned int last) __attribute__((visibility("hidden")));
|
||||
void bl_fsync_fds_closed(unsigned int first, unsigned int last) {
|
||||
int fd = __atomic_load_n(&fs_fd, __ATOMIC_ACQUIRE);
|
||||
if (fd >= 0 && (unsigned int)fd >= first && (unsigned int)fd <= last) __atomic_store_n(&fs_fd, -1, __ATOMIC_RELEASE);
|
||||
}
|
||||
|
||||
int bl_fsync_syscall(long number, const long *args, long *ret) __attribute__((visibility("hidden")));
|
||||
int bl_fsync_syscall(long number, const long *args, long *ret) {
|
||||
if (number == SYS_futex_waitv) {
|
||||
if (!fs_on()) return 0;
|
||||
if (!args[0] && !args[1]) {
|
||||
errno = EINVAL;
|
||||
*ret = -1;
|
||||
return 1;
|
||||
}
|
||||
*ret = fs_waitv((const struct fs_waitv *)args[0], (uint32_t)args[1], (uint32_t)args[2],
|
||||
(const struct timespec *)args[3], (int)args[4]);
|
||||
return 1;
|
||||
}
|
||||
if (number == SYS_futex && (int)args[1] == FUTEX_WAKE && fs_reg && __atomic_load_n(&fs_cur, __ATOMIC_RELAXED)) {
|
||||
uint32_t key;
|
||||
if (!fs_key_of((uint64_t)args[0], &key)) return 0;
|
||||
*ret = fs_wake(key, (int)args[2]);
|
||||
return 1;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int fs_fsync_name(const char *name) {
|
||||
size_t n;
|
||||
if (!name) return 0;
|
||||
if (*name == '/') name++;
|
||||
n = strlen(name);
|
||||
return n > 11 && !strncmp(name, "wine-", 5) && !strcmp(name + n - 6, "-fsync");
|
||||
}
|
||||
|
||||
static void fs_attach(const char *name, int fd, int create) {
|
||||
char path[256];
|
||||
struct stat st;
|
||||
void *p;
|
||||
int rfd;
|
||||
if (fs_reg) {
|
||||
fs_fd = fd;
|
||||
return;
|
||||
}
|
||||
if (snprintf(path, sizeof(path), "%s-droiddeck", name) >= (int)sizeof(path)) return;
|
||||
if (create) fs_real_shm_unlink(path);
|
||||
rfd = fs_real_shm_open(path, O_RDWR | O_CREAT, 0644);
|
||||
if (rfd < 0) {
|
||||
fprintf(stderr, "droiddeck-fsync: cannot open %s: %s\n", path, strerror(errno));
|
||||
return;
|
||||
}
|
||||
if (fstat(rfd, &st) == 0 && (size_t)st.st_size < FS_REGION && ftruncate(rfd, (off_t)FS_REGION) != 0) {
|
||||
fprintf(stderr, "droiddeck-fsync: cannot size %s: %s\n", path, strerror(errno));
|
||||
close(rfd);
|
||||
return;
|
||||
}
|
||||
if (!fs_real_mmap) fs_real_mmap = (void *(*)(void *, size_t, int, int, int, off_t))dlsym(RTLD_NEXT, "mmap");
|
||||
p = fs_real_mmap(NULL, FS_REGION, PROT_READ | PROT_WRITE, MAP_SHARED, rfd, 0);
|
||||
close(rfd);
|
||||
if (p == MAP_FAILED) {
|
||||
fprintf(stderr, "droiddeck-fsync: cannot map %s: %s\n", path, strerror(errno));
|
||||
return;
|
||||
}
|
||||
fs_reg = p;
|
||||
fs_fd = fd;
|
||||
if (create) {
|
||||
__atomic_store_n(&fs_head()->magic, FS_MAGIC, __ATOMIC_RELEASE);
|
||||
fprintf(stderr, "droiddeck-fsync: up and running.\n");
|
||||
}
|
||||
}
|
||||
|
||||
int shm_open(const char *name, int oflag, mode_t mode) {
|
||||
int fd, saved;
|
||||
if (!fs_real_shm_open) fs_real_shm_open = (int (*)(const char *, int, mode_t))dlsym(RTLD_NEXT, "shm_open");
|
||||
if (!fs_real_shm_unlink) fs_real_shm_unlink = (int (*)(const char *))dlsym(RTLD_NEXT, "shm_unlink");
|
||||
if (!fs_real_shm_open) {
|
||||
errno = ENOSYS;
|
||||
return -1;
|
||||
}
|
||||
fd = fs_real_shm_open(name, oflag, mode);
|
||||
if (fd >= 0 && fs_on() && fs_fsync_name(name) && fs_real_shm_unlink) {
|
||||
saved = errno;
|
||||
fs_attach(name, fd, oflag & O_CREAT);
|
||||
errno = saved;
|
||||
}
|
||||
return fd;
|
||||
}
|
||||
|
||||
int shm_unlink(const char *name) {
|
||||
int r, saved;
|
||||
if (!fs_real_shm_unlink) fs_real_shm_unlink = (int (*)(const char *))dlsym(RTLD_NEXT, "shm_unlink");
|
||||
if (!fs_real_shm_unlink) {
|
||||
errno = ENOSYS;
|
||||
return -1;
|
||||
}
|
||||
r = fs_real_shm_unlink(name);
|
||||
if (fs_on() && fs_fsync_name(name)) {
|
||||
char path[256];
|
||||
saved = errno;
|
||||
if (snprintf(path, sizeof(path), "%s-droiddeck", name) < (int)sizeof(path)) fs_real_shm_unlink(path);
|
||||
errno = saved;
|
||||
}
|
||||
return r;
|
||||
}
|
||||
|
||||
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 && __builtin_expect(fs_fd >= 0, 0)) fs_track(p, len, flags, fd, off);
|
||||
return p;
|
||||
}
|
||||
|
||||
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 && __builtin_expect(fs_fd >= 0, 0)) fs_track(p, len, flags, fd, off);
|
||||
return p;
|
||||
}
|
||||
|
||||
int munmap(void *addr, size_t len) {
|
||||
uintptr_t lo = (uintptr_t)addr, hi = lo + len;
|
||||
sigset_t old;
|
||||
int r, saved;
|
||||
if (!fs_real_munmap) fs_real_munmap = (int (*)(void *, size_t))dlsym(RTLD_NEXT, "munmap");
|
||||
if (__builtin_expect(fs_fd < 0, 1) || !fs_overlaps(lo, hi)) return fs_real_munmap(addr, len);
|
||||
fs_block(&old);
|
||||
pthread_mutex_lock(&fs_mx);
|
||||
r = fs_real_munmap(addr, len);
|
||||
saved = errno;
|
||||
if (r == 0) fs_rebuild_locked(lo, hi, NULL);
|
||||
pthread_mutex_unlock(&fs_mx);
|
||||
pthread_sigmask(SIG_SETMASK, &old, NULL);
|
||||
errno = saved;
|
||||
return r;
|
||||
}
|
||||
@@ -89,7 +89,7 @@ static void discover_pads(void) {
|
||||
|
||||
if (pad->devnode[0] == '\0') {
|
||||
snprintf(pad->sysname, sizeof(pad->sysname), "event%ld", slot);
|
||||
snprintf(pad->syspath, sizeof(pad->syspath), "/sys/devices/virtual/input/bannerlator%ld",
|
||||
snprintf(pad->syspath, sizeof(pad->syspath), "/sys/devices/virtual/input/droiddeck%ld",
|
||||
slot);
|
||||
snprintf(pad->devnode, sizeof(pad->devnode), "/dev/input/event%ld", slot);
|
||||
snprintf(pad->uevent, sizeof(pad->uevent), PAD_UEVENT_FORMAT, (int)slot, (int)slot);
|
||||
@@ -153,7 +153,7 @@ static void refresh_pad(int node) {
|
||||
|
||||
if (read_virtual_uevent(node, uevent, sizeof(uevent))) {
|
||||
snprintf(pad->sysname, sizeof(pad->sysname), "event%d", node);
|
||||
snprintf(pad->syspath, sizeof(pad->syspath), "/sys/devices/virtual/input/bannerlator%d", node);
|
||||
snprintf(pad->syspath, sizeof(pad->syspath), "/sys/devices/virtual/input/droiddeck%d", node);
|
||||
memcpy(pad->uevent, uevent, sizeof(uevent));
|
||||
pad->devnum = makedev(13, EVENT_MINOR_BASE + (unsigned int)node);
|
||||
snprintf(pad->devnode, sizeof(pad->devnode), "/dev/input/event%d", node);
|
||||
|
||||
@@ -20,6 +20,8 @@
|
||||
#include <sys/stat.h>
|
||||
#include <sys/types.h>
|
||||
#include <errno.h>
|
||||
#include <signal.h>
|
||||
#include <time.h>
|
||||
#include <unistd.h>
|
||||
|
||||
static const char *net_dir(void) {
|
||||
@@ -123,9 +125,75 @@ int listen(int fd, int backlog) {
|
||||
return ret;
|
||||
}
|
||||
|
||||
static unsigned local_port(int fd) {
|
||||
struct sockaddr_storage ss;
|
||||
socklen_t len = sizeof(ss);
|
||||
if (getsockname(fd, (struct sockaddr *)&ss, &len) != 0) {
|
||||
return 0;
|
||||
}
|
||||
return addr_port((struct sockaddr *)&ss, len);
|
||||
}
|
||||
|
||||
static void bind_before_loopback_connect(int fd, const struct sockaddr *addr, socklen_t len) {
|
||||
if (!addr || addr->sa_family != AF_INET || len < sizeof(struct sockaddr_in) ||
|
||||
((const struct sockaddr_in *)addr)->sin_addr.s_addr != htonl(INADDR_LOOPBACK)) {
|
||||
return;
|
||||
}
|
||||
struct sockaddr_storage ss;
|
||||
socklen_t slen = sizeof(ss);
|
||||
if (getsockname(fd, (struct sockaddr *)&ss, &slen) != 0 || ss.ss_family != AF_INET ||
|
||||
((struct sockaddr_in *)&ss)->sin_port != 0) {
|
||||
return;
|
||||
}
|
||||
struct sockaddr_in local;
|
||||
memset(&local, 0, sizeof(local));
|
||||
local.sin_family = AF_INET;
|
||||
local.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
|
||||
int saved = errno;
|
||||
bind(fd, (struct sockaddr *)&local, sizeof(local));
|
||||
errno = saved;
|
||||
}
|
||||
|
||||
static unsigned guarded_port(void) {
|
||||
static int port = -1;
|
||||
if (port < 0) {
|
||||
const char *value = getenv("BL_CDP_GUARD");
|
||||
port = value && *value ? atoi(value) : 0;
|
||||
if (port < 0 || port > 65535) port = 0;
|
||||
}
|
||||
return (unsigned)port;
|
||||
}
|
||||
|
||||
static int guest_peer(int fd) {
|
||||
unsigned peer = peer_port(fd);
|
||||
if (peer == 0) {
|
||||
return 0;
|
||||
}
|
||||
char path[300];
|
||||
snprintf(path, sizeof(path), "%s/p%u", net_dir(), peer);
|
||||
struct stat st;
|
||||
if (stat(path, &st) != 0 || time(NULL) - st.st_mtime > 30) {
|
||||
return 0;
|
||||
}
|
||||
int in = open(path, O_RDONLY);
|
||||
if (in < 0) {
|
||||
return 0;
|
||||
}
|
||||
char buf[64];
|
||||
int n = read(in, buf, sizeof(buf) - 1);
|
||||
close(in);
|
||||
if (n <= 0) {
|
||||
return 0;
|
||||
}
|
||||
buf[n] = '\0';
|
||||
int pid = atoi(buf);
|
||||
return pid > 0 && (kill(pid, 0) == 0 || errno != ESRCH);
|
||||
}
|
||||
|
||||
int connect(int fd, const struct sockaddr *addr, socklen_t len) {
|
||||
static connect_fn real;
|
||||
if (!real) real = (connect_fn)dlsym(RTLD_NEXT, "connect");
|
||||
bind_before_loopback_connect(fd, addr, len);
|
||||
int ret = real(fd, addr, len);
|
||||
if (ret == 0 || errno == EINPROGRESS) {
|
||||
/* The caller goes on to test for EINPROGRESS, which the bookkeeping must not disturb. */
|
||||
@@ -139,9 +207,17 @@ int connect(int fd, const struct sockaddr *addr, socklen_t len) {
|
||||
int accept4(int fd, struct sockaddr *addr, socklen_t *len, int flags) {
|
||||
static accept4_fn real;
|
||||
if (!real) real = (accept4_fn)dlsym(RTLD_NEXT, "accept4");
|
||||
int ret = real(fd, addr, len, flags);
|
||||
if (ret >= 0) record_port(ret, peer_port(ret));
|
||||
return ret;
|
||||
for (;;) {
|
||||
int ret = real(fd, addr, len, flags);
|
||||
if (ret < 0) return ret;
|
||||
unsigned guarded = guarded_port();
|
||||
if (guarded && local_port(ret) == guarded && !guest_peer(ret)) {
|
||||
close(ret);
|
||||
continue;
|
||||
}
|
||||
record_port(ret, peer_port(ret));
|
||||
return ret;
|
||||
}
|
||||
}
|
||||
|
||||
int accept(int fd, struct sockaddr *addr, socklen_t *len) {
|
||||
|
||||
@@ -8,7 +8,7 @@
|
||||
* address ioctl, and every table under /proc/net. Wine builds its adapter, address, route and
|
||||
* neighbour tables from exactly those, so a game saw a machine with no adapter, no address, no
|
||||
* gateway and no MAC, and one that checks its adapters before going online waited for good.
|
||||
* The app knows the real link from ConnectivityManager and writes it to /etc/bannerlator-net;
|
||||
* The app knows the real link from ConnectivityManager and writes it to /etc/droiddeck-net;
|
||||
* whatever the kernel refuses is answered from that file. Anything the kernel does answer wins.
|
||||
*/
|
||||
#define _GNU_SOURCE 1
|
||||
@@ -30,7 +30,7 @@
|
||||
#include <sys/socket.h>
|
||||
#include <unistd.h>
|
||||
|
||||
#define LINK_FILE "/etc/bannerlator-net"
|
||||
#define LINK_FILE "/etc/droiddeck-net"
|
||||
#define LO_NAME "lo"
|
||||
#define LO_INDEX 1
|
||||
#define LO_MTU 65536
|
||||
@@ -352,6 +352,7 @@ static int is_link_query(unsigned long request) {
|
||||
void bl_kgsl_chip_id_fixup(unsigned long request, void *arg, int rc); /* kgslid.c */
|
||||
int bl_kgsl_poll(int (*real)(int, unsigned long, void *), int fd, unsigned long request,
|
||||
void *arg, int *rc) __attribute__((visibility("hidden")));
|
||||
int bl_ntsync_ioctl(int fd, unsigned long request, void *arg, int *rc) __attribute__((visibility("hidden")));
|
||||
|
||||
/* Every DRM and evdev call comes through here, so the lookup is done once. Two threads racing
|
||||
* to store it store the same pointer. */
|
||||
@@ -363,8 +364,9 @@ int ioctl(int fd, unsigned long request, ...) {
|
||||
void *arg = va_arg(ap, void *);
|
||||
va_end(ap);
|
||||
|
||||
if (real == NULL) real = (ioctl_fn) dlsym(RTLD_NEXT, "ioctl");
|
||||
int rc;
|
||||
if (bl_ntsync_ioctl(fd, request, arg, &rc)) return rc;
|
||||
if (real == NULL) real = (ioctl_fn) dlsym(RTLD_NEXT, "ioctl");
|
||||
if (!bl_kgsl_poll(real, fd, request, arg, &rc)) rc = real(fd, request, arg);
|
||||
bl_kgsl_chip_id_fixup(request, arg, rc);
|
||||
if (arg == NULL || !is_link_query(request)) return rc;
|
||||
@@ -466,7 +468,7 @@ static const char *denied_table(const char *path) {
|
||||
static FILE *synthesize(const char *table) {
|
||||
struct link link;
|
||||
if (!load_link(&link)) return NULL;
|
||||
int fd = memfd_create("bannerlator-net", MFD_CLOEXEC);
|
||||
int fd = memfd_create("droiddeck-net", MFD_CLOEXEC);
|
||||
if (fd < 0) return NULL;
|
||||
FILE *out = fdopen(fd, "w+");
|
||||
if (out == NULL) {
|
||||
|
||||
File diff suppressed because it is too large.
Load diff
@@ -35,6 +35,7 @@
|
||||
|
||||
int bl_status_without_tracer(const char *path, int flags) __attribute__((visibility("hidden")));
|
||||
int bl_writable_retry(int dirfd, const char *path, int flags) __attribute__((visibility("hidden")));
|
||||
int bl_ntsync_open(const char *path, int flags) __attribute__((visibility("hidden")));
|
||||
|
||||
static int retry_without_noatime(int fd, int flags) {
|
||||
return fd < 0 && errno == EPERM && (flags & O_NOATIME);
|
||||
@@ -61,6 +62,7 @@ int open(const char *path, int flags, ...) {
|
||||
return -1;
|
||||
}
|
||||
if ((fd = bl_status_without_tracer(path, flags)) >= 0) return fd;
|
||||
if ((fd = bl_ntsync_open(path, flags)) != -2) return fd;
|
||||
if (real_open == NULL) real_open = dlsym(RTLD_NEXT, "open");
|
||||
if (real_open == NULL) {
|
||||
errno = ENOSYS;
|
||||
@@ -87,6 +89,7 @@ int openat(int dirfd, const char *path, int flags, ...) {
|
||||
return -1;
|
||||
}
|
||||
if ((fd = bl_status_without_tracer(path, flags)) >= 0) return fd;
|
||||
if ((fd = bl_ntsync_open(path, flags)) != -2) return fd;
|
||||
if (real_openat == NULL) real_openat = dlsym(RTLD_NEXT, "openat");
|
||||
if (real_openat == NULL) {
|
||||
errno = ENOSYS;
|
||||
|
||||
@@ -9,6 +9,7 @@
|
||||
#define _GNU_SOURCE
|
||||
#include <dlfcn.h>
|
||||
#include <errno.h>
|
||||
#include <fcntl.h>
|
||||
#include <linux/futex.h>
|
||||
#include <pthread.h>
|
||||
#include <stdarg.h>
|
||||
@@ -18,7 +19,23 @@
|
||||
#include <sys/uio.h>
|
||||
#include <unistd.h>
|
||||
|
||||
#ifndef SYS_openat2
|
||||
#define SYS_openat2 437
|
||||
#endif
|
||||
|
||||
#define BL_RESOLVE_BENEATH 0x08
|
||||
#define BL_RESOLVE_IN_ROOT 0x10
|
||||
|
||||
struct bl_open_how {
|
||||
uint64_t flags;
|
||||
uint64_t mode;
|
||||
uint64_t resolve;
|
||||
};
|
||||
|
||||
static long (*real_syscall)(long, ...);
|
||||
static int openat2_missing;
|
||||
|
||||
int bl_fsync_syscall(long number, const long *args, long *ret) __attribute__((visibility("hidden")));
|
||||
|
||||
static struct robust_list_head *thread_robust_head(void) {
|
||||
pthread_mutexattr_t attr;
|
||||
@@ -54,6 +71,35 @@ static struct robust_list_head *thread_robust_head(void) {
|
||||
return head;
|
||||
}
|
||||
|
||||
static long openat2_via_openat(const long *args) {
|
||||
const char *path = (const char *)args[1];
|
||||
const struct bl_open_how *how = (const struct bl_open_how *)args[2];
|
||||
if (!path || !how || (size_t)args[3] < sizeof(*how)) {
|
||||
errno = EINVAL;
|
||||
return -1;
|
||||
}
|
||||
if (how->resolve & BL_RESOLVE_IN_ROOT) {
|
||||
while (*path == '/') {
|
||||
path++;
|
||||
}
|
||||
if (!*path) {
|
||||
path = ".";
|
||||
}
|
||||
} else if ((how->resolve & BL_RESOLVE_BENEATH) && *path == '/') {
|
||||
errno = EXDEV;
|
||||
return -1;
|
||||
}
|
||||
return real_syscall(SYS_openat, args[0], (long)path, (long)(int)how->flags, (long)how->mode);
|
||||
}
|
||||
|
||||
static int execveat_is_execve(const long *args) {
|
||||
const char *path = (const char *)args[1];
|
||||
if (!path || (args[4] & (AT_EMPTY_PATH | AT_SYMLINK_NOFOLLOW))) {
|
||||
return 0;
|
||||
}
|
||||
return path[0] == '/' || (int)args[0] == AT_FDCWD;
|
||||
}
|
||||
|
||||
long syscall(long number, ...) {
|
||||
va_list ap;
|
||||
long args[6];
|
||||
@@ -72,8 +118,25 @@ long syscall(long number, ...) {
|
||||
*(size_t *)args[2] = sizeof(*head);
|
||||
return 0;
|
||||
}
|
||||
long handled;
|
||||
if (bl_fsync_syscall(number, args, &handled)) {
|
||||
return handled;
|
||||
}
|
||||
if (!real_syscall) {
|
||||
real_syscall = (long (*)(long, ...)) dlsym(RTLD_NEXT, "syscall");
|
||||
}
|
||||
if (number == SYS_openat2) {
|
||||
if (!__atomic_load_n(&openat2_missing, __ATOMIC_RELAXED)) {
|
||||
long fd = real_syscall(number, args[0], args[1], args[2], args[3]);
|
||||
if (fd != -1 || errno != ENOSYS) {
|
||||
return fd;
|
||||
}
|
||||
__atomic_store_n(&openat2_missing, 1, __ATOMIC_RELAXED);
|
||||
}
|
||||
return openat2_via_openat(args);
|
||||
}
|
||||
if (number == SYS_execveat && execveat_is_execve(args)) {
|
||||
return real_syscall(SYS_execve, args[1], args[2], args[3]);
|
||||
}
|
||||
return real_syscall(number, args[0], args[1], args[2], args[3], args[4], args[5]);
|
||||
}
|
||||
@@ -0,0 +1,3 @@
|
||||
URUNTIME_VERSION=v0.8.1
|
||||
URUNTIME_ASSET=uruntime-appimage-lite-aarch64
|
||||
URUNTIME_SHA256=8485ae20eb0bfd4eaeac38d7fd7f78e153b391c718cf33ff07879605683be1ea
|
||||
@@ -2,7 +2,7 @@ import os, sys
|
||||
paths = ["/etc/os-release", "/root/abs-link", "/root/to-bind", "/root/to-bind/inbind.txt", "/root/rel-to-bind",
|
||||
"/root/rel-to-bind/inbind.txt", "/root/dotdot", "/root/dotdot/libc.so.6", "/root/dangling", "/root/loop",
|
||||
"/usr/lib/../lib/libc.so.6", "/usr//lib/./libc.so.6", "/lib", "/lib/libc.so.6", "/bin/env", "/nope", "/nope/x",
|
||||
"/etc/os-release/x", "/mnt/droiddeck-sd", "/mnt/droiddeck-sd/inbind.txt", "/mnt/droiddeck-sd/../bannerlator",
|
||||
"/etc/os-release/x", "/mnt/droiddeck-sd", "/mnt/droiddeck-sd/inbind.txt", "/mnt/droiddeck-sd/../droiddeck",
|
||||
"/dev/null", "/dev/shm", "/dev/shm/inbind.txt", "/dev/random", "/proc/self/exe", "/proc/version", "/proc",
|
||||
"/sys/class/thermal/thermal_zone28/temp", "/sdcard", "/", "/tmp", "/root/in-root-abs-dir/os-release",
|
||||
"/data/local/tmp/dd/tmp/inbind.txt", "/data/local/tmp/dd/mini/etc/os-release", "/root/to-bind/missing/x", "/root/to-bind/inbind.txt/x", "/usr/lib/nope/deeper/x.so", "/mnt/droiddeck-sd/nope/x", "/root/dangling/x", "/root/abs-link/x", "/nope/a/b/c", "/sdcard/nope/x"]
|
||||
|
||||
@@ -13,7 +13,7 @@ D=/data/local/tmp/dd
|
||||
V=$1; shift
|
||||
U=$(id -u)
|
||||
REL="\\Linux\\DroidDeck\\$(uname -r)\\$(uname -v)\\aarch64\\localdomain\\-1\\"
|
||||
BINDS="-b /dev -b /proc -b /sys -b /dev/urandom:/dev/random -b /proc/self/fd:/dev/fd -b /proc/self/fd/0:/dev/stdin -b /proc/self/fd/1:/dev/stdout -b /proc/self/fd/2:/dev/stderr -b $D/tmp:/dev/shm -b $D -b /sdcard -b /data/local/tmp/dd/mini/etc/os-release:/proc/version -b $D/mini/etc/os-release:/proc/loadavg -b $D/mini/etc/os-release:/proc/uptime -b /sys/class/thermal/thermal_zone0/temp:/sys/class/thermal/thermal_zone28/temp -b $D/tmp:/mnt/droiddeck-sd -b $D/tmp:/mnt/bannerlator"
|
||||
BINDS="-b /dev -b /proc -b /sys -b /dev/urandom:/dev/random -b /proc/self/fd:/dev/fd -b /proc/self/fd/0:/dev/stdin -b /proc/self/fd/1:/dev/stdout -b /proc/self/fd/2:/dev/stderr -b $D/tmp:/dev/shm -b $D -b /sdcard -b /data/local/tmp/dd/mini/etc/os-release:/proc/version -b $D/mini/etc/os-release:/proc/loadavg -b $D/mini/etc/os-release:/proc/uptime -b /sys/class/thermal/thermal_zone0/temp:/sys/class/thermal/thermal_zone28/temp -b $D/tmp:/mnt/droiddeck-sd -b $D/tmp:/mnt/droiddeck"
|
||||
export PROOT_TMP_DIR=$D/tmp
|
||||
case $V in
|
||||
patched) export PROOT_LOADER=$D/loader; exec $D/proot --kill-on-exit --kernel-release="$REL" -i $U:$U -r $D/mini -w /root $BINDS /usr/bin/env -i HOME=/root PATH=/usr/bin LANG=C.UTF-8 "$@" ;;
|
||||
|
||||
@@ -8,7 +8,8 @@ OVERLAY = Path(__file__).resolve().parents[1] / 'linuxfs/overlay'
|
||||
|
||||
|
||||
def check(apk, overlay=OVERLAY):
|
||||
sources = list((overlay / 'usr/local/bin').glob('bannerlator-*'))
|
||||
sources = list((overlay / 'usr/local/bin').glob('droiddeck-*'))
|
||||
sources += [path for path in [overlay / 'usr/local/bin/steam-compatibility'] if path.is_file()]
|
||||
sources += [path for path in (overlay / 'usr/bin').rglob('*') if path.is_file()]
|
||||
errors = []
|
||||
with ZipFile(apk) as package:
|
||||
|
||||
@@ -0,0 +1,132 @@
|
||||
import os
|
||||
import shutil
|
||||
import subprocess
|
||||
import tempfile
|
||||
import unittest
|
||||
from pathlib import Path
|
||||
|
||||
RUN = Path(__file__).resolve().parents[1] / "linuxfs/overlay/usr/local/bin/droiddeck-appimage-run"
|
||||
KEYS = ("QT_QPA_PLATFORM", "WAYLAND_DISPLAY", "SDL_VIDEODRIVER", "XDG_SESSION_TYPE", "QT_WAYLAND_DISABLE_WINDOWDECORATION", "DISABLE_GAMESCOPE_WSI")
|
||||
QUICK = ("usr/lib/libQt6Quick.so.6", "usr/lib/libvulkan.so.1", "usr/plugins/platforms/libqwayland-generic.so")
|
||||
RUN_MODE = {"GAMESCOPE_WAYLAND_DISPLAY": "gamescope-0", "WAYLAND_DISPLAY": "gamescope-0", "DISPLAY": ":0",
|
||||
"QT_QPA_PLATFORM": "xcb", "SDL_VIDEODRIVER": "x11", "XDG_SESSION_TYPE": "x11"}
|
||||
DESKTOP = {"WAYLAND_DISPLAY": "wayland-1", "DISPLAY": ":1", "QT_QPA_PLATFORM": "wayland;xcb",
|
||||
"SDL_VIDEODRIVER": "wayland,x11", "XDG_SESSION_TYPE": "wayland"}
|
||||
|
||||
|
||||
class AppImageRunTest(unittest.TestCase):
|
||||
def setUp(self):
|
||||
self.tmp = Path(tempfile.mkdtemp())
|
||||
self.addCleanup(shutil.rmtree, self.tmp, True)
|
||||
self.dir = self.tmp / "opennow"
|
||||
self.out = self.tmp / "env"
|
||||
app = self.dir / "app"
|
||||
app.mkdir(parents=True)
|
||||
run = app / "AppRun"
|
||||
run.write_text("#!/bin/sh\nfor k in %s; do eval \"echo $k=\\${$k-unset}\"; done > %s\n" % (" ".join(KEYS), self.out))
|
||||
run.chmod(0o755)
|
||||
|
||||
def bundle(self, *paths):
|
||||
for path in paths:
|
||||
lib = self.dir / "app" / path
|
||||
lib.parent.mkdir(parents=True, exist_ok=True)
|
||||
lib.write_bytes(b"")
|
||||
|
||||
def launch(self, session):
|
||||
env = {k: v for k, v in os.environ.items() if k not in KEYS + ("GAMESCOPE_WAYLAND_DISPLAY", "DISPLAY")}
|
||||
env.update(session, HOME=str(self.tmp / "home"), DBUS_SESSION_BUS_ADDRESS="unix:path=/dev/null")
|
||||
result = subprocess.run(["bash", str(RUN), str(self.dir)], env=env, capture_output=True, text=True, timeout=30)
|
||||
self.assertEqual(0, result.returncode, result.stderr)
|
||||
return dict(line.split("=", 1) for line in self.out.read_text().splitlines()), result.stdout
|
||||
|
||||
def test_a_vulkan_qt_quick_app_draws_on_gamescope_wayland(self):
|
||||
self.bundle(*QUICK)
|
||||
env, log = self.launch(RUN_MODE)
|
||||
self.assertEqual("wayland;xcb", env["QT_QPA_PLATFORM"])
|
||||
self.assertEqual("gamescope-0", env["WAYLAND_DISPLAY"])
|
||||
self.assertEqual("wayland", env["SDL_VIDEODRIVER"])
|
||||
self.assertEqual("wayland", env["XDG_SESSION_TYPE"])
|
||||
self.assertEqual("1", env["QT_WAYLAND_DISABLE_WINDOWDECORATION"])
|
||||
self.assertEqual("1", env["DISABLE_GAMESCOPE_WSI"])
|
||||
self.assertIn("Qt wayland (wayland;xcb)", log)
|
||||
|
||||
def test_a_quick_app_that_loads_vulkan_itself_is_found_by_its_binary(self):
|
||||
self.bundle(QUICK[0], QUICK[2])
|
||||
binary = self.dir / "app/usr/bin/opennow-qt"
|
||||
binary.parent.mkdir(parents=True, exist_ok=True)
|
||||
binary.write_bytes(b"\x7fELF\0_ZN7QWindow17setVulkanInstanceEP15QVulkanInstance\0")
|
||||
env, _ = self.launch(RUN_MODE)
|
||||
self.assertEqual("wayland;xcb", env["QT_QPA_PLATFORM"])
|
||||
self.assertEqual("1", env["DISABLE_GAMESCOPE_WSI"])
|
||||
|
||||
def test_other_apps_stay_on_xwayland(self):
|
||||
self.bundle("usr/lib/libQt6Widgets.so.6", "usr/lib/libvulkan.so.1", "usr/plugins/platforms/libqxcb.so")
|
||||
env, _ = self.launch(RUN_MODE)
|
||||
self.assertEqual("xcb", env["QT_QPA_PLATFORM"])
|
||||
self.assertEqual("x11", env["SDL_VIDEODRIVER"])
|
||||
self.assertEqual("unset", env["QT_WAYLAND_DISABLE_WINDOWDECORATION"])
|
||||
self.assertEqual("unset", env["DISABLE_GAMESCOPE_WSI"])
|
||||
|
||||
def test_a_quick_app_without_the_wayland_plugin_stays_on_xwayland(self):
|
||||
self.bundle(*QUICK[:2])
|
||||
env, log = self.launch(RUN_MODE)
|
||||
self.assertEqual("xcb", env["QT_QPA_PLATFORM"])
|
||||
self.assertIn("stays on X11", log)
|
||||
|
||||
def test_the_desktop_keeps_its_decorations(self):
|
||||
self.bundle(*QUICK)
|
||||
env, _ = self.launch(DESKTOP)
|
||||
self.assertEqual("wayland;xcb", env["QT_QPA_PLATFORM"])
|
||||
self.assertEqual("wayland-1", env["WAYLAND_DISPLAY"])
|
||||
self.assertEqual("wayland", env["SDL_VIDEODRIVER"])
|
||||
self.assertEqual("unset", env["QT_WAYLAND_DISABLE_WINDOWDECORATION"])
|
||||
self.assertEqual("unset", env["DISABLE_GAMESCOPE_WSI"])
|
||||
|
||||
def test_how_the_program_ended_is_logged(self):
|
||||
run = self.dir / "app/AppRun"
|
||||
run.write_text("#!/bin/sh\nexit 3\n")
|
||||
env = {k: v for k, v in os.environ.items() if k not in KEYS}
|
||||
env.update(RUN_MODE, HOME=str(self.tmp / "home"), DBUS_SESSION_BUS_ADDRESS="unix:path=/dev/null")
|
||||
result = subprocess.run(["bash", str(RUN), str(self.dir)], env=env, capture_output=True, text=True, timeout=30)
|
||||
self.assertEqual(3, result.returncode)
|
||||
self.assertIn("exited with status 3", result.stdout)
|
||||
run.write_text("#!/bin/sh\nkill -SEGV $$\n")
|
||||
result = subprocess.run(["bash", str(RUN), str(self.dir)], env=env, capture_output=True, text=True, timeout=30)
|
||||
self.assertEqual(139, result.returncode)
|
||||
self.assertIn("ended by signal 11 (SEGV)", result.stdout)
|
||||
|
||||
def test_a_failed_program_shows_the_log_it_wrote(self):
|
||||
home = self.tmp / "home"
|
||||
old = home / ".local/share/emulator/log/old.log"
|
||||
old.parent.mkdir(parents=True)
|
||||
old.write_text("from an earlier run\n")
|
||||
os.utime(old, (1, 1))
|
||||
(self.dir / "app/AppRun").write_text(
|
||||
"#!/bin/sh\nmkdir -p \"$HOME/.local/share/emulator/log\"\n"
|
||||
"printf 'Assertion failed: vulkan device\\n\\345\\001\\n' > \"$HOME/.local/share/emulator/log/emulator_log.txt\"\n"
|
||||
"kill -ILL $$\n")
|
||||
env = {k: v for k, v in os.environ.items() if k not in KEYS}
|
||||
env.update(RUN_MODE, HOME=str(home), DBUS_SESSION_BUS_ADDRESS="unix:path=/dev/null")
|
||||
result = subprocess.run(["bash", str(RUN), str(self.dir)], env=env, capture_output=True, text=True, timeout=30)
|
||||
self.assertIn("ended by signal 4 (ILL)", result.stdout)
|
||||
self.assertIn("end of %s" % (home / ".local/share/emulator/log/emulator_log.txt"), result.stdout)
|
||||
self.assertIn("Assertion failed: vulkan device", result.stdout)
|
||||
self.assertNotIn("from an earlier run", result.stdout)
|
||||
(self.dir / "app/AppRun").write_text("#!/bin/sh\necho again > \"$HOME/.local/share/emulator/log/emulator_log.txt\"\n")
|
||||
result = subprocess.run(["bash", str(RUN), str(self.dir)], env=env, capture_output=True, text=True, timeout=30)
|
||||
self.assertNotIn("end of", result.stdout)
|
||||
|
||||
def test_the_per_app_choice_wins(self):
|
||||
self.bundle(*QUICK)
|
||||
(self.dir / "qt").write_text("xcb\n")
|
||||
env, log = self.launch(DESKTOP)
|
||||
self.assertEqual("xcb", env["QT_QPA_PLATFORM"])
|
||||
self.assertIn("Qt xcb (xcb)", log)
|
||||
(self.dir / "qt").write_text("wayland\n")
|
||||
(self.dir / "app/usr/lib/libQt6Quick.so.6").unlink()
|
||||
env, _ = self.launch(RUN_MODE)
|
||||
self.assertEqual("wayland;xcb", env["QT_QPA_PLATFORM"])
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
@@ -6,7 +6,7 @@ import unittest
|
||||
from unittest.mock import patch
|
||||
|
||||
|
||||
HELPER = Path(__file__).resolve().parents[1] / "linuxfs/overlay/usr/local/bin/bannerlator-desktop-bookmarks"
|
||||
HELPER = Path(__file__).resolve().parents[1] / "linuxfs/overlay/usr/local/bin/droiddeck-desktop-bookmarks"
|
||||
MODULE = runpy.run_path(str(HELPER))
|
||||
|
||||
|
||||
|
||||
@@ -0,0 +1,551 @@
|
||||
import contextlib
|
||||
import gzip
|
||||
import io
|
||||
import json
|
||||
import os
|
||||
import runpy
|
||||
import shutil
|
||||
import struct
|
||||
import tempfile
|
||||
import unittest
|
||||
from pathlib import Path
|
||||
from unittest import mock
|
||||
|
||||
BIN = Path(__file__).resolve().parents[1] / "linuxfs/overlay/usr/local/bin"
|
||||
FEX = runpy.run_path(str(BIN / "droiddeck-fex"))
|
||||
G = FEX["main"].__globals__
|
||||
|
||||
|
||||
def elf(machine, data=1, size=64):
|
||||
head = bytearray(size)
|
||||
head[0:4] = b"\x7fELF"
|
||||
head[4] = 2
|
||||
head[5] = data
|
||||
struct.pack_into("<H" if data == 1 else ">H", head, 18, machine)
|
||||
return bytes(head)
|
||||
|
||||
|
||||
class FexTestCase(unittest.TestCase):
|
||||
def setUp(self):
|
||||
self.tmp = Path(tempfile.mkdtemp())
|
||||
self.addCleanup(shutil.rmtree, self.tmp, True)
|
||||
self.home = self.tmp / "home"
|
||||
self.steam = self.home / ".local/share/Steam"
|
||||
(self.steam / "steamapps/common").mkdir(parents=True)
|
||||
state = self.home / ".local/share/droiddeck-fex"
|
||||
patches = {
|
||||
"HOME": str(self.home),
|
||||
"STEAM_ROOT": str(self.steam),
|
||||
"LIBRARIES": (str(self.tmp / "sd"),),
|
||||
"STATE": str(state),
|
||||
"CONFIG_DIR": str(state / "config"),
|
||||
"DATA_DIR": str(state / "data"),
|
||||
"CACHE_DIR": str(self.home / ".cache/droiddeck-fex"),
|
||||
"STATUS_FILE": str(state / "status.json"),
|
||||
"WANTED": str(self.home / ".config/droiddeck/fex-wanted"),
|
||||
"PRELOADS": str(self.tmp / "preloads"),
|
||||
"HOST_PRELOAD": str(self.tmp / "ld.so.preload"),
|
||||
}
|
||||
patcher = mock.patch.dict(G, patches)
|
||||
patcher.start()
|
||||
self.addCleanup(patcher.stop)
|
||||
|
||||
def write(self, path, data=b"", mode=0o644):
|
||||
path = Path(path)
|
||||
path.parent.mkdir(parents=True, exist_ok=True)
|
||||
path.write_bytes(data if isinstance(data, bytes) else data.encode())
|
||||
path.chmod(mode)
|
||||
return path
|
||||
|
||||
def fex_tool(self, library=None, server=True, thunks=True):
|
||||
tool = Path(library or self.steam) / "steamapps/common/FEX-Emu"
|
||||
self.write(tool / "usr/bin/FEX", elf(183), 0o755)
|
||||
if server:
|
||||
self.write(tool / "usr/bin/FEXServer", elf(183), 0o755)
|
||||
if thunks:
|
||||
(tool / "usr/lib/aarch64-linux-gnu/fex-emu/HostThunks").mkdir(parents=True)
|
||||
(tool / "usr/share/fex-emu/GuestThunks").mkdir(parents=True)
|
||||
self.write(tool / "usr/share/fex-emu/ThunksDB.json", "{}")
|
||||
self.write(Path(library or self.steam) / "steamapps/appmanifest_3127680.acf", '"AppState" { "installdir" "FEX-Emu" }')
|
||||
return tool
|
||||
|
||||
def runtime(self, version="3.0.20260805.254768", lines=None):
|
||||
runtime = self.steam / "steamapps/common/SteamLinuxRuntime_sniper"
|
||||
platform = runtime / ("sniper_platform_" + version)
|
||||
files = platform / "files"
|
||||
self.write(files / "lib/x86_64-linux-gnu/libc.so.6", elf(62))
|
||||
self.write(files / "ab/cdef-1.bin", b"blob")
|
||||
self.write(files / "share/ca/real.crt", b"cert")
|
||||
mtree = lines or [
|
||||
"#mtree",
|
||||
". type=dir",
|
||||
"./bin type=dir",
|
||||
"./lib64 type=dir",
|
||||
"./lib64/ld-linux-x86-64.so.2 type=link link=/usr/lib/x86_64-linux-gnu/ld-2.31.so",
|
||||
"./lib/x86_64-linux-gnu/libc.so.6 type=file mode=644 size=64",
|
||||
"./bin/\\133 type=file mode=755 size=4 contents=./ab/cdef-1.bin",
|
||||
"./share/ca/Na\\075me.crt type=link link=real.crt",
|
||||
"./etc/ssl/cert.pem type=link link=/etc/ssl/certs/ca.pem",
|
||||
]
|
||||
with gzip.open(platform / "usr-mtree.txt.gz", "wt") as out:
|
||||
out.write("\n".join(mtree) + "\n")
|
||||
self.write(self.steam / "steamapps/appmanifest_1628350.acf", '"AppState" { "installdir" "SteamLinuxRuntime_sniper" }')
|
||||
return platform
|
||||
|
||||
def quiet(self, function, *args):
|
||||
with contextlib.redirect_stderr(io.StringIO()) as err:
|
||||
return function(*args), err.getvalue()
|
||||
|
||||
|
||||
class ArchitectureTest(FexTestCase):
|
||||
def test_elf_machines(self):
|
||||
self.assertEqual(FEX["elf_arch"](self.write(self.tmp / "a", elf(62))), "x86_64")
|
||||
self.assertEqual(FEX["elf_arch"](self.write(self.tmp / "b", elf(3))), "i386")
|
||||
self.assertEqual(FEX["elf_arch"](self.write(self.tmp / "c", elf(183))), "arm64")
|
||||
self.assertEqual(FEX["elf_arch"](self.write(self.tmp / "d", elf(62, data=2))), "x86_64")
|
||||
self.assertEqual(FEX["elf_arch"](self.write(self.tmp / "e", elf(8))), "other")
|
||||
self.assertIsNone(FEX["elf_arch"](self.write(self.tmp / "f", "#!/bin/sh\n")))
|
||||
self.assertIsNone(FEX["elf_arch"](self.tmp / "missing"))
|
||||
|
||||
def test_a_script_follows_the_programs_beside_it(self):
|
||||
game = self.tmp / "game"
|
||||
script = self.write(game / "start.sh", "#!/bin/bash\n./bin/game\n")
|
||||
self.assertFalse(FEX["needs_fex"](str(script)))
|
||||
self.write(game / "bin/game.x86_64", elf(62), 0o755)
|
||||
self.assertTrue(FEX["needs_fex"](str(script)))
|
||||
self.assertTrue(FEX["needs_fex"](str(game)))
|
||||
self.write(game / "bin/game.arm64", elf(183), 0o755)
|
||||
self.assertFalse(FEX["needs_fex"](str(script)))
|
||||
self.assertTrue(FEX["needs_fex"](str(game / "bin/game.x86_64")))
|
||||
self.assertFalse(FEX["needs_fex"](str(game / "bin/game.arm64")))
|
||||
|
||||
def test_the_scan_stops_at_its_depth(self):
|
||||
game = self.tmp / "deep"
|
||||
self.write(game / "a/b/c/d/e/game", elf(62), 0o755)
|
||||
self.assertFalse(FEX["needs_fex"](str(game)))
|
||||
self.write(game / "a/b/game", elf(62), 0o755)
|
||||
self.assertTrue(FEX["needs_fex"](str(game)))
|
||||
|
||||
def test_appimage_offset_is_the_end_of_the_section_headers(self):
|
||||
head = bytearray(elf(62))
|
||||
struct.pack_into("<Q", head, 0x28, 1000)
|
||||
struct.pack_into("<HH", head, 0x3A, 64, 30)
|
||||
self.assertEqual(FEX["appimage_offset"](self.write(self.tmp / "x.AppImage", bytes(head))), 1000 + 64 * 30)
|
||||
head = bytearray(elf(3))
|
||||
head[4] = 1
|
||||
struct.pack_into("<I", head, 0x20, 500)
|
||||
struct.pack_into("<HH", head, 0x2E, 40, 10)
|
||||
self.assertEqual(FEX["appimage_offset"](self.write(self.tmp / "y.AppImage", bytes(head))), 900)
|
||||
|
||||
def test_run_options(self):
|
||||
self.assertEqual(FEX["parse_run"](["--mode", "on", "--for", "/x", "--", "a", "--mode"]), ("on", "/x", ["a", "--mode"]))
|
||||
self.assertEqual(FEX["parse_run"](["a"]), ("auto", None, ["a"]))
|
||||
with self.assertRaises(ValueError):
|
||||
FEX["parse_run"](["--mode", "maybe", "a"])
|
||||
with self.assertRaises(ValueError):
|
||||
FEX["parse_run"](["--bogus", "a"])
|
||||
|
||||
|
||||
class LocateTest(FexTestCase):
|
||||
def test_tools_are_found_in_any_library(self):
|
||||
self.assertIsNone(FEX["fex_install"]() if not os.access("/usr/bin/FEX", os.X_OK) else None)
|
||||
sd = self.tmp / "sd"
|
||||
(sd / "steamapps/common").mkdir(parents=True)
|
||||
tool = self.fex_tool(sd)
|
||||
fex = FEX["fex_install"]()
|
||||
self.assertEqual((fex["bin"], fex["server"], fex["portable"]), (str(tool / "usr/bin/FEX"), str(tool / "usr/bin/FEXServer"), True))
|
||||
self.assertTrue(fex["host_thunks"].endswith("HostThunks") and fex["guest_thunks"].endswith("GuestThunks") and fex["thunks_db"])
|
||||
|
||||
def test_library_folders_are_read(self):
|
||||
other = self.tmp / "other"
|
||||
(other / "steamapps/common").mkdir(parents=True)
|
||||
self.write(self.steam / "steamapps/libraryfolders.vdf", '"libraryfolders" { "1" { "path" "%s" } }' % other)
|
||||
tool = self.fex_tool(other)
|
||||
self.assertEqual(FEX["app_dir"]("3127680"), str(tool))
|
||||
|
||||
def test_the_newest_runtime_platform_wins(self):
|
||||
self.runtime("3.0.20260805.254768")
|
||||
newer = self.runtime("3.0.20261001.1")
|
||||
self.assertEqual(FEX["runtime_platform"](), str(newer))
|
||||
|
||||
|
||||
class PrepareTest(FexTestCase):
|
||||
def test_materialize_links_the_tree_in_place(self):
|
||||
platform = self.runtime()
|
||||
files = platform / "files"
|
||||
self.assertTrue(FEX["materialize"](str(platform)))
|
||||
self.assertEqual(os.readlink(files / "lib64/ld-linux-x86-64.so.2"), "../lib/x86_64-linux-gnu/ld-2.31.so")
|
||||
self.assertEqual(os.readlink(files / "bin/["), "../ab/cdef-1.bin")
|
||||
self.assertEqual((files / "bin/[").read_bytes(), b"blob")
|
||||
self.assertEqual((files / "share/ca/Na=me.crt").read_bytes(), b"cert")
|
||||
self.assertEqual(os.readlink(files / "etc/ssl/cert.pem"), "certs/ca.pem")
|
||||
self.assertEqual(os.readlink(files / "usr"), ".")
|
||||
self.assertEqual((files / "usr/lib/x86_64-linux-gnu/libc.so.6").read_bytes()[:4], b"\x7fELF")
|
||||
self.assertFalse(FEX["materialize"](str(platform)))
|
||||
os.unlink(files / "bin/[")
|
||||
os.utime(platform / "usr-mtree.txt.gz", ns=(1, 1))
|
||||
self.assertTrue(FEX["materialize"](str(platform)))
|
||||
self.assertTrue(os.path.islink(files / "bin/["))
|
||||
|
||||
def test_materialize_ignores_paths_outside_the_tree(self):
|
||||
platform = self.runtime(lines=["./../escape type=link link=x", "/abs type=dir", "./ok type=link link=x"])
|
||||
FEX["materialize"](str(platform))
|
||||
self.assertFalse((platform / "escape").exists() or os.path.islink(platform / "escape"))
|
||||
self.assertTrue(os.path.islink(platform / "files/ok"))
|
||||
|
||||
def test_preloads_mirror_the_host_list(self):
|
||||
root = self.tmp / "root"
|
||||
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(),
|
||||
"/usr/$LIB/droiddeck/libblsession.so\n/usr/$LIB/droiddeck/libfakeinput.so\n")
|
||||
self.assertEqual((root / "lib/i386-linux-gnu/droiddeck/libfakeinput.so").read_bytes(), b"i386libfakeinput.so")
|
||||
self.write(self.tmp / "ld.so.preload", "/usr/local/lib/libblsession.so\n")
|
||||
FEX["install_preloads"](str(root))
|
||||
self.assertEqual((root / "etc/ld.so.preload").read_text(), "/usr/$LIB/droiddeck/libblsession.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())
|
||||
self.assertEqual(config, {"Config": {"RootFS": "/root", "ThunkHostLibs": "/h", "ThunkGuestLibs": "/g"}, "ThunksDB": {"GL": 1, "Vulkan": 1}})
|
||||
FEX["write_config"]({"host_thunks": None, "guest_thunks": "/g", "thunks_db": "/db"}, "/root")
|
||||
config = json.loads((self.home / ".local/share/droiddeck-fex/config/Config.json").read_text())
|
||||
self.assertEqual(config, {"Config": {"RootFS": "/root"}})
|
||||
|
||||
def test_missing_pieces_are_asked_for(self):
|
||||
with mock.patch.dict(G, {"fex_install": lambda: None, "steam_running": lambda: False}):
|
||||
fex, said = self.quiet(FEX["prepare"])
|
||||
self.assertIsNone(fex)
|
||||
self.assertIn("FEX (Steam app 3127680)", said)
|
||||
self.assertIn("Steam Linux Runtime 3.0", said)
|
||||
self.assertTrue(said.startswith("droiddeck-fex: x86 Linux programs need "))
|
||||
self.assertTrue((self.home / ".config/droiddeck/fex-wanted").is_file())
|
||||
status = json.loads((self.home / ".local/share/droiddeck-fex/status.json").read_text())
|
||||
self.assertFalse(status["ready"])
|
||||
|
||||
def test_a_ready_install_is_prepared(self):
|
||||
tool = self.fex_tool()
|
||||
platform = self.runtime()
|
||||
self.write(self.home / ".config/droiddeck/fex-wanted", "1\n")
|
||||
fex, said = self.quiet(FEX["prepare"])
|
||||
self.assertEqual(fex["bin"], str(tool / "usr/bin/FEX"))
|
||||
self.assertIn("prepared sniper_platform_", said)
|
||||
self.assertTrue(os.path.islink(platform / "files/usr"))
|
||||
status = json.loads((self.home / ".local/share/droiddeck-fex/status.json").read_text())
|
||||
self.assertEqual((status["ready"], status["runtime"], status["thunks"]), (True, str(platform), True))
|
||||
self.assertFalse((self.home / ".config/droiddeck/fex-wanted").exists())
|
||||
self.assertEqual(self.quiet(FEX["prepare"])[1], "")
|
||||
|
||||
def test_status_refreshes_what_the_app_reads_once_steam_installed_fex(self):
|
||||
with mock.patch.dict(G, {"steam_running": lambda: False}):
|
||||
self.quiet(FEX["prepare"])
|
||||
status_file = self.home / ".local/share/droiddeck-fex/status.json"
|
||||
self.assertFalse(json.loads(status_file.read_text())["ready"])
|
||||
self.fex_tool()
|
||||
self.runtime()
|
||||
with contextlib.redirect_stdout(io.StringIO()) as out:
|
||||
self.assertEqual(0, FEX["main"](["status"]))
|
||||
self.assertTrue(json.loads(out.getvalue())["ready"])
|
||||
self.assertTrue(json.loads(status_file.read_text())["ready"])
|
||||
|
||||
def test_fex_is_found_at_the_tool_root_too(self):
|
||||
tool = self.steam / "steamapps/common/FEX-Emu"
|
||||
self.write(tool / "bin/FEX", elf(183), 0o755)
|
||||
self.write(tool / "bin/FEXServer", elf(183), 0o755)
|
||||
self.write(self.steam / "steamapps/appmanifest_3127680.acf", '"AppState" { "installdir" "FEX-Emu" }')
|
||||
fex = FEX["fex_install"]()
|
||||
self.assertEqual((fex["bin"], fex["server"], fex["portable"]), (str(tool / "bin/FEX"), str(tool / "bin/FEXServer"), True))
|
||||
|
||||
def test_an_installed_tool_without_fex_says_what_it_holds(self):
|
||||
tool = self.steam / "steamapps/common/FEX-Emu"
|
||||
self.write(tool / "toolmanifest.vdf", "")
|
||||
self.write(self.steam / "steamapps/appmanifest_3127680.acf", '"AppState" { "installdir" "FEX-Emu" }')
|
||||
with mock.patch.dict(G, {"steam_running": lambda: False}), mock.patch("shutil.which", return_value=None), \
|
||||
mock.patch("os.access", lambda path, mode: False):
|
||||
fex, said = self.quiet(FEX["prepare"])
|
||||
self.assertIsNone(fex)
|
||||
self.assertIn("holds no FEX or FEXInterpreter", said)
|
||||
self.assertIn("toolmanifest.vdf", said)
|
||||
|
||||
def test_a_missing_server_is_not_ready(self):
|
||||
self.fex_tool(server=False)
|
||||
self.runtime()
|
||||
with mock.patch.dict(G, {"steam_running": lambda: False}), mock.patch("shutil.which", return_value=None):
|
||||
fex, said = self.quiet(FEX["prepare"])
|
||||
self.assertIsNone(fex)
|
||||
self.assertIn("FEXServer beside", said)
|
||||
|
||||
|
||||
class ExtractTest(FexTestCase):
|
||||
def setUp(self):
|
||||
super().setUp()
|
||||
self.work = self.tmp / "work"
|
||||
self.work.mkdir()
|
||||
self.image = self.write(self.work / "image.AppImage", elf(62) + b"payload", 0o755)
|
||||
chdir = contextlib.chdir(self.work)
|
||||
chdir.__enter__()
|
||||
self.addCleanup(chdir.__exit__, None, None, None)
|
||||
|
||||
def uruntime(self, body):
|
||||
return str(self.write(self.tmp / "uruntime", "#!/bin/sh\n" + body, 0o755))
|
||||
|
||||
def test_uruntime_unpacks_an_x86_image_without_fex(self):
|
||||
tool = self.uruntime('[ "$1" = --appimage-extract ] && [ "$TARGET_APPIMAGE" = "%s" ] || exit 9\nmkdir -p AppDir && touch AppDir/AppRun\n' % self.image)
|
||||
with mock.patch.dict(G, {"URUNTIME": tool, "fex_install": lambda: None, "steam_running": lambda: False}):
|
||||
status, said = self.quiet(FEX["extract"], "image.AppImage")
|
||||
self.assertEqual((status, said), (0, ""))
|
||||
self.assertEqual(os.readlink("squashfs-root"), "AppDir")
|
||||
self.assertTrue(Path("squashfs-root/AppRun").is_file())
|
||||
self.assertTrue((self.home / ".config/droiddeck/fex-wanted").is_file())
|
||||
self.assertFalse(json.loads((self.home / ".local/share/droiddeck-fex/status.json").read_text())["ready"])
|
||||
|
||||
def test_an_arm64_image_does_not_ask_for_fex(self):
|
||||
self.write(self.image, elf(183) + b"payload", 0o755)
|
||||
tool = self.uruntime("mkdir -p squashfs-root\n")
|
||||
with mock.patch.dict(G, {"URUNTIME": tool}):
|
||||
status, said = self.quiet(FEX["extract"], "image.AppImage")
|
||||
self.assertEqual((status, said), (0, ""))
|
||||
self.assertFalse((self.home / ".config/droiddeck/fex-wanted").exists())
|
||||
|
||||
def test_nothing_to_unpack_with_says_so(self):
|
||||
tool = self.uruntime("mkdir -p squashfs-root\nexit 1\n")
|
||||
with mock.patch.dict(G, {"URUNTIME": tool, "fex_install": lambda: None, "steam_running": lambda: False}), \
|
||||
mock.patch("shutil.which", return_value=None):
|
||||
status, said = self.quiet(FEX["extract"], "image.AppImage")
|
||||
self.assertEqual(status, 1)
|
||||
self.assertIn("uruntime could not extract it (status 1)", said)
|
||||
self.assertIn("no AppImage runtime for ARM64, no FEX yet and no unsquashfs", said)
|
||||
self.assertFalse(os.path.lexists("squashfs-root"))
|
||||
|
||||
|
||||
class LaunchTest(FexTestCase):
|
||||
def test_the_guest_environment(self):
|
||||
arm = self.write(self.tmp / "arm.so", elf(183))
|
||||
x86 = self.write(self.tmp / "x86.so", elf(62))
|
||||
env = {"LD_PRELOAD": "%s:%s %s" % (arm, x86, self.tmp / "gone.so"),
|
||||
"LD_LIBRARY_PATH": "/steam/steamrtarm64:/usr/lib/aarch64-linux-gnu:/game/lib",
|
||||
"FEX_ROOTFS": "/usr/share/guestos/fex-mesa", "FEX_TSOENABLED": "1"}
|
||||
guest = FEX["guest_environment"]({"portable": True}, env)
|
||||
self.assertEqual((guest["LD_PRELOAD"], guest["LD_LIBRARY_PATH"], guest["FEX_PORTABLE"]), (str(x86), "/game/lib", "1"))
|
||||
self.assertNotIn("FEX_ROOTFS", guest)
|
||||
self.assertEqual(guest["FEX_TSOENABLED"], "1")
|
||||
self.assertTrue(guest["FEX_APP_CONFIG_LOCATION"].endswith("/config/"))
|
||||
self.assertEqual((guest["FEX_SILENTLOG"], guest["FEX_OUTPUTLOG"]), ("0", "stderr"))
|
||||
guest = FEX["guest_environment"]({"portable": False}, {"LD_PRELOAD": str(arm), "FEX_PORTABLE": "1", "FEX_OUTPUTLOG": "/tmp/fex.log"})
|
||||
self.assertEqual(guest["FEX_OUTPUTLOG"], "/tmp/fex.log")
|
||||
self.assertNotIn("LD_PRELOAD", guest)
|
||||
self.assertNotIn("FEX_PORTABLE", guest)
|
||||
|
||||
def test_the_runtime_and_thunks_are_passed_to_fex(self):
|
||||
fex = {"portable": True, "rootfs": "/rt/files", "host_thunks": "/h", "guest_thunks": "/g", "thunks_db": "/db"}
|
||||
guest = FEX["guest_environment"](fex, {})
|
||||
self.assertEqual((guest["FEX_ROOTFS"], guest["FEX_THUNKHOSTLIBS"], guest["FEX_THUNKGUESTLIBS"]), ("/rt/files", "/h", "/g"))
|
||||
self.assertTrue(guest["FEX_THUNKCONFIG"].endswith("/config/ThunksConfig.json"))
|
||||
guest = FEX["guest_environment"](dict(fex, host_thunks=None), {})
|
||||
self.assertEqual(guest["FEX_ROOTFS"], "/rt/files")
|
||||
self.assertNotIn("FEX_THUNKCONFIG", guest)
|
||||
FEX["write_config"](fex, "/rt/files")
|
||||
thunks = json.loads((self.home / ".local/share/droiddeck-fex/config/ThunksConfig.json").read_text())
|
||||
self.assertEqual(thunks, {"ThunksDB": {"GL": 1, "Vulkan": 1}})
|
||||
|
||||
def test_native_programs_run_directly(self):
|
||||
program = self.write(self.tmp / "native", elf(183), 0o755)
|
||||
with mock.patch("os.execvpe") as native, mock.patch("os.execve") as emulated:
|
||||
FEX["launch"]([str(program), "--flag"], {"PATH": "/usr/bin"}, "auto")
|
||||
native.assert_called_once_with(str(program), [str(program), "--flag"], {"PATH": "/usr/bin"})
|
||||
emulated.assert_not_called()
|
||||
|
||||
def test_x86_programs_run_under_fex(self):
|
||||
tool = self.fex_tool()
|
||||
self.runtime()
|
||||
program = self.write(self.tmp / "game.x86_64", elf(62), 0o755)
|
||||
with mock.patch("os.execvpe") as native, mock.patch("os.execve") as emulated:
|
||||
self.quiet(FEX["launch"], [str(program), "-w"], {"PATH": "/usr/bin"}, "auto")
|
||||
native.assert_not_called()
|
||||
binary, argv, env = emulated.call_args[0]
|
||||
self.assertEqual((binary, argv), (str(tool / "usr/bin/FEX"), [str(tool / "usr/bin/FEX"), str(program), "-w"]))
|
||||
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))
|
||||
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)
|
||||
old = self.write(self.tmp / "game.i386", elf(3), 0o755)
|
||||
with mock.patch("os.execve") as emulated:
|
||||
self.quiet(FEX["launch"], [str(old)], {}, "auto")
|
||||
self.assertNotIn("LD_PRELOAD", emulated.call_args[0][2])
|
||||
with mock.patch("os.execvpe") as native, mock.patch("os.execve") as emulated:
|
||||
self.quiet(FEX["launch"], [str(program)], {}, "off")
|
||||
native.assert_called_once()
|
||||
emulated.assert_not_called()
|
||||
|
||||
def test_programs_that_bring_a_new_enough_runtime_get_the_vulkan_thunk(self):
|
||||
tool = self.fex_tool()
|
||||
self.runtime()
|
||||
self.write(tool / "usr/share/fex-emu/GuestThunks/libvulkan-guest.so",
|
||||
elf(62) + b"\0libstdc++.so.6\0GLIBCXX_3.4\0GLIBCXX_3.4.29\0libc.so.6\0GLIBC_2.2.5\0GLIBC_2.34\0")
|
||||
self.write(self.tmp / "preloads/x86_64/libthunkaudit.so", elf(62))
|
||||
pin = self.write(self.tmp / "preloads/x86_64/libvulkan-thunk.so", elf(62))
|
||||
audit = "/usr/lib/x86_64-linux-gnu/droiddeck/libthunkaudit.so"
|
||||
|
||||
def app(name, glibc=b"GLIBC_2.34\0GLIBC_2.44", glibcxx=b"GLIBCXX_3.4.29\0GLIBCXX_3.4.36", bundled=True):
|
||||
run = self.write(self.tmp / name / "AppRun", elf(62), 0o755)
|
||||
if bundled:
|
||||
self.write(self.tmp / name / "shared/lib/libc.so.6", elf(62) + b"\0GLIBC_2.2.5\0" + glibc + b"\0")
|
||||
self.write(self.tmp / name / "shared/lib/libstdc++.so.6",
|
||||
elf(62) + b"\0GLIBCXX_3.4\0" + glibcxx + b"\0GLIBC_2.34\0")
|
||||
return run
|
||||
|
||||
def started(program, env=None, decide=None):
|
||||
with mock.patch("os.execve") as emulated:
|
||||
_, said = self.quiet(FEX["launch"], [str(program)], dict(env or {}), "on", decide)
|
||||
return emulated.call_args[0][2], said
|
||||
|
||||
env, said = started(app("new"))
|
||||
self.assertEqual(env["LD_AUDIT"], audit)
|
||||
self.assertIn("thunks on, its own Vulkan loader too", said)
|
||||
env, _ = started(app("kept"), {"LD_AUDIT": "/opt/audit.so"})
|
||||
self.assertEqual(env["LD_AUDIT"], audit + ":/opt/audit.so")
|
||||
env, _ = started(self.write(self.tmp / "elsewhere/run.sh", "#!/bin/sh\n", 0o755), decide=str(self.tmp / "new"))
|
||||
self.assertEqual(env["LD_AUDIT"], audit)
|
||||
env, said = started(app("old-cxx", glibcxx=b"GLIBCXX_3.4.28"))
|
||||
self.assertNotIn("LD_AUDIT", env)
|
||||
self.assertIn("thunks on)", said)
|
||||
self.assertNotIn("LD_AUDIT", started(app("old-libc", glibc=b"GLIBC_2.31"))[0])
|
||||
self.assertNotIn("LD_AUDIT", started(app("runtime-only", bundled=False))[0])
|
||||
i386 = self.write(self.tmp / "new/game.i386", elf(3), 0o755)
|
||||
self.assertNotIn("LD_AUDIT", started(i386)[0])
|
||||
pin.unlink()
|
||||
self.assertNotIn("LD_AUDIT", started(app("no-pin"))[0])
|
||||
self.write(pin, elf(62))
|
||||
(tool / "usr/share/fex-emu/GuestThunks/libvulkan-guest.so").unlink()
|
||||
self.assertNotIn("LD_AUDIT", started(app("no-thunk"))[0])
|
||||
|
||||
def test_steam_verbs(self):
|
||||
with mock.patch.dict(G, {"launch": mock.Mock(return_value=0)}):
|
||||
self.assertEqual(FEX["main"](["steam", "getcompatpath", "/x"]), 0)
|
||||
G["launch"].assert_not_called()
|
||||
FEX["main"](["steam", "waitforexitandrun", "/game/run.sh", "-a"])
|
||||
command, env, mode = G["launch"].call_args[0]
|
||||
self.assertEqual((command, mode), (["/game/run.sh", "-a"], "auto"))
|
||||
|
||||
|
||||
class AppInfoTest(unittest.TestCase):
|
||||
COMPAT = runpy.run_path(str(BIN / "steam-compatibility"))
|
||||
|
||||
@staticmethod
|
||||
def appinfo(apps, magic=0x07564429):
|
||||
strings = []
|
||||
|
||||
def key(name):
|
||||
if magic != 0x07564429:
|
||||
return name.encode() + b"\0"
|
||||
if name not in strings:
|
||||
strings.append(name)
|
||||
return struct.pack("<I", strings.index(name))
|
||||
|
||||
def section(items):
|
||||
out = b""
|
||||
for name, value in items.items():
|
||||
if isinstance(value, dict):
|
||||
out += b"\x00" + key(name) + section(value)
|
||||
else:
|
||||
out += b"\x01" + key(name) + value.encode() + b"\0"
|
||||
return out + b"\x08"
|
||||
|
||||
body = b""
|
||||
for app, entry in apps.items():
|
||||
if isinstance(entry, dict):
|
||||
data = section({"appinfo": dict(entry, appid=str(app))})
|
||||
else:
|
||||
oslist, osarch, kind = entry
|
||||
data = section({"appinfo": {"appid": str(app), "common": {"type": kind, "oslist": oslist, "osarch": osarch}}})
|
||||
header = struct.pack("<IIQ", 2, 0, 0) + b"\0" * 20 + struct.pack("<I", 1) + (b"\0" * 20 if magic >= 0x07564428 else b"")
|
||||
body += struct.pack("<II", app, len(header) + len(data)) + header + data
|
||||
body += struct.pack("<I", 0)
|
||||
if magic != 0x07564429:
|
||||
return struct.pack("<II", magic, 1) + body
|
||||
table_at = 16 + len(body)
|
||||
table = struct.pack("<I", len(strings)) + b"".join(s.encode() + b"\0" for s in strings)
|
||||
return struct.pack("<IIq", magic, 1, table_at) + body + table
|
||||
|
||||
def test_linux_only_titles_are_sent_to_fex(self):
|
||||
for magic in (0x07564427, 0x07564428, 0x07564429):
|
||||
with tempfile.TemporaryDirectory() as tmp:
|
||||
steam = Path(tmp)
|
||||
(steam / "appcache").mkdir()
|
||||
(steam / "appcache/appinfo.vdf").write_bytes(self.appinfo({
|
||||
10: ("windows", "", "Game"), 20: ("linux", "64", "Game"), 30: ("windows,linux,macos", "", "game"),
|
||||
40: ("linux", "arm64", "game"), 50: ("linux", "", "Demo"), 70: ("linux", "", "Tool"), 80: ("linux", "", "config"),
|
||||
90: ("linux", "", ""),
|
||||
}, magic))
|
||||
self.COMPAT["APPINFO_CACHE"].clear()
|
||||
targets = self.COMPAT["native_targets"](str(steam), ["10", "20", "30", "40", "50", "70", "80", "90", "1628350", "60"])
|
||||
self.assertEqual(targets, {"20": "droiddeck-fex", "50": "droiddeck-fex"}, hex(magic))
|
||||
|
||||
def test_titles_with_a_valve_pick_are_found_installed_or_not(self):
|
||||
def deck(oslist, runtime, kind="game"):
|
||||
common = {"type": kind, "oslist": oslist, "steam_deck_compatibility": {"configuration": {"recommended_runtime": runtime}}}
|
||||
if oslist is None:
|
||||
del common["oslist"]
|
||||
return {"common": common}
|
||||
for magic in (0x07564427, 0x07564428, 0x07564429):
|
||||
with tempfile.TemporaryDirectory() as tmp:
|
||||
steam = Path(tmp)
|
||||
(steam / "appcache").mkdir()
|
||||
(steam / "appcache/appinfo.vdf").write_bytes(self.appinfo({
|
||||
10: deck("windows", "proton-stable"), 11: deck("windows,linux", "native"), 12: deck(None, "proton-7.0-5"),
|
||||
13: deck("linux", "native"), 14: deck("windows", "proton-stable", "Tool"), 15: ("windows", "", "game"),
|
||||
16: ("windows", "", "game"), 1628350: deck("linux", "native", "game"),
|
||||
891390: {"common": {"type": "Config"}, "extended": {"app_mappings": {
|
||||
"16": {"appid": "16", "tool": "proton-stable"}, "17": {"appid": "17", "tool": ""}}}},
|
||||
}, magic))
|
||||
self.COMPAT["APPINFO_CACHE"].clear()
|
||||
self.assertEqual(self.COMPAT["valve_picks"](str(steam)), ["10", "11", "12", "16"], hex(magic))
|
||||
|
||||
def test_titles_with_a_valve_pick_follow_the_default_until_the_user_picks(self):
|
||||
tool = self.COMPAT["TOOL"]
|
||||
changes, auto = self.COMPAT["plan_mapping"](
|
||||
{"0": tool, "31": "GE-Proton11-7", "32": "proton_11_arm64", "33": "steamlinuxruntime"},
|
||||
["40"], [tool, "GE-Proton11-7"], tool, {}, {}, ["30", "31", "32", "33"])
|
||||
self.assertEqual(changes, {"30": tool, "32": tool, "40": tool})
|
||||
self.assertEqual(auto, {"30": tool, "32": tool, "40": tool})
|
||||
changes, auto = self.COMPAT["plan_mapping"](
|
||||
{"0": "GE-Proton11-7", "30": tool, "31": "GE-Proton11-7", "32": tool}, [], [tool, "GE-Proton11-7"], "GE-Proton11-7", auto, {}, ["30", "31", "32"])
|
||||
self.assertEqual(changes, {"30": "GE-Proton11-7", "32": "GE-Proton11-7"})
|
||||
self.assertEqual(auto, {"30": "GE-Proton11-7", "32": "GE-Proton11-7"})
|
||||
|
||||
def test_the_mapping_sends_native_titles_to_fex_and_keeps_picks(self):
|
||||
tool, fex = self.COMPAT["TOOL"], self.COMPAT["FEX_TOOL"]
|
||||
changes, auto = self.COMPAT["plan_mapping"](
|
||||
{"0": tool, "20": "fex", "21": "steamlinuxruntime_sniper", "22": "GE-Proton11-7"},
|
||||
["20", "21", "22", "23", "24"], [tool, "GE-Proton11-7"], tool, {},
|
||||
{"20": fex, "21": fex, "22": fex, "23": fex})
|
||||
self.assertEqual(changes, {"20": fex, "21": fex, "23": fex, "24": tool})
|
||||
self.assertEqual(auto, {"20": fex, "21": fex, "23": fex, "24": tool})
|
||||
|
||||
def test_the_tool_files(self):
|
||||
with tempfile.TemporaryDirectory() as tmp:
|
||||
tool = Path(tmp) / "droiddeck-fex"
|
||||
self.COMPAT["build_fex_tool"](str(tool))
|
||||
self.assertEqual(sorted(os.listdir(tool)), sorted(self.COMPAT["FEX_FILES"]))
|
||||
self.assertIn('"commandline" "/droiddeck-fex-tool %verb%"', (tool / "toolmanifest.vdf").read_text())
|
||||
self.assertTrue(os.access(tool / "droiddeck-fex-tool", os.X_OK))
|
||||
vdf = (tool / "compatibilitytool.vdf").read_text()
|
||||
self.assertIn('"from_oslist" "linux"', vdf)
|
||||
self.assertIn('"to_oslist" "linux"', vdf)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
File diff suppressed because it is too large.
Load diff
@@ -0,0 +1,346 @@
|
||||
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 <errno.h>
|
||||
#include <fcntl.h>
|
||||
#include <linux/futex.h>
|
||||
#include <pthread.h>
|
||||
#include <signal.h>
|
||||
#include <stdint.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <sys/mman.h>
|
||||
#include <sys/stat.h>
|
||||
#include <sys/syscall.h>
|
||||
#include <sys/wait.h>
|
||||
#include <time.h>
|
||||
#include <unistd.h>
|
||||
|
||||
struct waitv { uint64_t val; uint64_t uaddr; uint32_t flags; uint32_t reserved; };
|
||||
|
||||
static char name[64];
|
||||
static int *page;
|
||||
|
||||
static long waitv(int **addrs, int *vals, int n, const struct timespec *ts, int clk) {
|
||||
struct waitv v[8];
|
||||
for (int i = 0; i < n; i++) {
|
||||
v[i].val = (uint32_t)vals[i];
|
||||
v[i].uaddr = (uintptr_t)addrs[i];
|
||||
v[i].flags = 2;
|
||||
v[i].reserved = 0;
|
||||
}
|
||||
return syscall(449, v, n, 0, ts, clk);
|
||||
}
|
||||
|
||||
static long waitv_retry(int **addrs, int *vals, int n) {
|
||||
long r;
|
||||
do r = waitv(addrs, vals, n, NULL, 0); while (r == -1 && errno == EINTR);
|
||||
return r;
|
||||
}
|
||||
|
||||
static void wake(int *addr) {
|
||||
syscall(SYS_futex, addr, FUTEX_WAKE, 0x7fffffff, NULL, NULL, 0);
|
||||
}
|
||||
|
||||
static void deadline(struct timespec *ts, int clk, long ms) {
|
||||
clock_gettime(clk, ts);
|
||||
ts->tv_sec += ms / 1000;
|
||||
ts->tv_nsec += (ms % 1000) * 1000000;
|
||||
if (ts->tv_nsec >= 1000000000) {
|
||||
ts->tv_sec++;
|
||||
ts->tv_nsec -= 1000000000;
|
||||
}
|
||||
}
|
||||
|
||||
static double now(void) {
|
||||
struct timespec ts;
|
||||
clock_gettime(CLOCK_MONOTONIC, &ts);
|
||||
return ts.tv_sec + ts.tv_nsec / 1e9;
|
||||
}
|
||||
|
||||
static int *map_page(int fd, int index) {
|
||||
int *p = mmap(NULL, 0x10000, PROT_READ | PROT_WRITE, MAP_SHARED, fd, (off_t)index * 0x10000);
|
||||
if (p == MAP_FAILED) { perror("mmap"); exit(2); }
|
||||
return p;
|
||||
}
|
||||
|
||||
#define CHECK(c, ...) do { if (!(c)) { printf("FAIL %d: ", __LINE__); printf(__VA_ARGS__); printf("\n"); exit(1); } } while (0)
|
||||
|
||||
static int client(void) {
|
||||
int fd = shm_open(name, O_RDWR, 0644);
|
||||
int *p, *addrs[3];
|
||||
int vals[3] = {0, 0, 0};
|
||||
long r;
|
||||
CHECK(fd >= 0, "client open %d", errno);
|
||||
p = map_page(fd, 1);
|
||||
addrs[0] = &p[0]; addrs[1] = &p[4]; addrs[2] = &p[8];
|
||||
__atomic_store_n(&p[12], 1, __ATOMIC_SEQ_CST);
|
||||
wake(&p[12]);
|
||||
r = waitv_retry(addrs, vals, 3);
|
||||
CHECK(r == 2, "client woke with %ld errno %d", r, errno);
|
||||
__atomic_store_n(&p[16], 1, __ATOMIC_SEQ_CST);
|
||||
wake(&p[16]);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int sleeper(void) {
|
||||
int fd = shm_open(name, O_RDWR, 0644);
|
||||
int *p = map_page(fd, 1), *a = &p[20], v = 0;
|
||||
__atomic_store_n(&p[24], 1, __ATOMIC_SEQ_CST);
|
||||
wake(&p[24]);
|
||||
for (;;) waitv(&a, &v, 1, NULL, 0);
|
||||
return 0;
|
||||
}
|
||||
|
||||
struct sem { int *count; int n; };
|
||||
static int *sems;
|
||||
static volatile int taken, given;
|
||||
#define SEMS 6
|
||||
#define ROUNDS 20000
|
||||
|
||||
static void *consumer(void *arg) {
|
||||
int got = 0;
|
||||
while (got < ROUNDS) {
|
||||
int *addrs[SEMS], vals[SEMS], i;
|
||||
for (i = 0; i < SEMS; i++) {
|
||||
int *c = &sems[i * 4], cur = __atomic_load_n(c, __ATOMIC_SEQ_CST);
|
||||
while (cur > 0) {
|
||||
if (__atomic_compare_exchange_n(c, &cur, cur - 1, 0, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST)) { got++; goto next; }
|
||||
}
|
||||
addrs[i] = c;
|
||||
vals[i] = 0;
|
||||
}
|
||||
waitv(addrs, vals, SEMS, NULL, 0);
|
||||
next:;
|
||||
}
|
||||
__atomic_add_fetch(&taken, got, __ATOMIC_SEQ_CST);
|
||||
return arg;
|
||||
}
|
||||
|
||||
static int churn_fd;
|
||||
static volatile int churn_stop;
|
||||
|
||||
static void *churn(void *arg) {
|
||||
while (!churn_stop) munmap(map_page(churn_fd, 1), 0x10000);
|
||||
return arg;
|
||||
}
|
||||
|
||||
static void *one_wait(void *arg) {
|
||||
int *q = map_page(churn_fd, 1), *a = &q[64], v = 0;
|
||||
long r;
|
||||
do r = waitv(&a, &v, 1, NULL, 0); while (r == -1 && errno == EINTR && !__atomic_load_n(a, __ATOMIC_SEQ_CST));
|
||||
munmap(q, 0x10000);
|
||||
return (void *)(intptr_t)(r == -1 && errno == EINTR);
|
||||
}
|
||||
|
||||
static int used_slots(void) {
|
||||
char reg[96];
|
||||
int fd, n = 0;
|
||||
uint64_t *head;
|
||||
snprintf(reg, sizeof(reg), "%s-droiddeck", name);
|
||||
fd = shm_open(reg, O_RDONLY, 0);
|
||||
if (fd < 0) return -1;
|
||||
head = mmap(NULL, 4096, PROT_READ, MAP_SHARED, fd, 0);
|
||||
close(fd);
|
||||
if (head == MAP_FAILED) return -1;
|
||||
for (int i = 0; i < 32; i++) n += __builtin_popcountll(__atomic_load_n(&head[3 + i], __ATOMIC_SEQ_CST));
|
||||
munmap(head, 4096);
|
||||
return n;
|
||||
}
|
||||
|
||||
static void *producer(void *arg) {
|
||||
unsigned seed = (unsigned)(uintptr_t)arg;
|
||||
for (int i = 0; i < ROUNDS; i++) {
|
||||
int *c = &sems[(rand_r(&seed) % SEMS) * 4];
|
||||
__atomic_add_fetch(c, 1, __ATOMIC_SEQ_CST);
|
||||
wake(c);
|
||||
__atomic_add_fetch(&given, 1, __ATOMIC_SEQ_CST);
|
||||
}
|
||||
return arg;
|
||||
}
|
||||
|
||||
int main(int argc, char **argv) {
|
||||
snprintf(name, sizeof(name), "/wine-%x-fsync", (unsigned)getpid() ^ 0x5a5a00);
|
||||
if (argc > 2) snprintf(name, sizeof(name), "%s", argv[2]);
|
||||
if (argc > 1 && !strcmp(argv[1], "client")) return client();
|
||||
if (argc > 1 && !strcmp(argv[1], "sleeper")) return sleeper();
|
||||
{
|
||||
long r = syscall(449, NULL, 0, 0, NULL, 0);
|
||||
CHECK(r == -1 && errno == EINVAL, "probe %ld errno %d", r, errno);
|
||||
}
|
||||
int fd = shm_open(name, O_RDWR | O_CREAT | O_EXCL, 0644);
|
||||
CHECK(fd >= 0, "create %d", errno);
|
||||
CHECK(ftruncate(fd, 0x20000) == 0, "truncate");
|
||||
page = map_page(fd, 1);
|
||||
{
|
||||
char reg[96];
|
||||
struct stat st;
|
||||
snprintf(reg, sizeof(reg), "/dev/shm%s-droiddeck", name);
|
||||
CHECK(stat(reg, &st) == 0 && st.st_size > 0, "registry %s missing", reg);
|
||||
}
|
||||
{
|
||||
int *a = &page[40], v = 1;
|
||||
long r = waitv(&a, &v, 1, NULL, 0);
|
||||
CHECK(r == -1 && errno == EAGAIN, "mismatch %ld errno %d", r, errno);
|
||||
}
|
||||
for (int clk = 0; clk < 2; clk++) {
|
||||
int c = clk ? CLOCK_REALTIME : CLOCK_MONOTONIC, *a = &page[44], v = 0;
|
||||
struct timespec ts;
|
||||
double t = now();
|
||||
long r;
|
||||
deadline(&ts, c, 150);
|
||||
do r = waitv(&a, &v, 1, &ts, c); while (r == -1 && errno == EINTR);
|
||||
t = now() - t;
|
||||
CHECK(r == -1 && errno == ETIMEDOUT && t > 0.12 && t < 1.5, "timeout clock %d r %ld errno %d after %.3f", c, r, errno, t);
|
||||
}
|
||||
{
|
||||
pid_t pid = fork();
|
||||
if (!pid) { execl("/proc/self/exe", argv[0], "client", name, (char *)NULL); _exit(3); }
|
||||
int *ready = &page[12], *done = &page[16], z = 0, st;
|
||||
double t = now();
|
||||
while (!__atomic_load_n(ready, __ATOMIC_SEQ_CST) && now() - t < 20) waitv(&ready, &z, 1, NULL, 0);
|
||||
usleep(20000);
|
||||
__atomic_store_n(&page[8], 1, __ATOMIC_SEQ_CST);
|
||||
wake(&page[8]);
|
||||
while (!__atomic_load_n(done, __ATOMIC_SEQ_CST) && now() - t < 20) waitv(&done, &z, 1, NULL, 0);
|
||||
CHECK(__atomic_load_n(done, __ATOMIC_SEQ_CST), "client never finished");
|
||||
waitpid(pid, &st, 0);
|
||||
CHECK(WIFEXITED(st) && WEXITSTATUS(st) == 0, "client status %d", st);
|
||||
}
|
||||
{
|
||||
int rounds = 2000, z = 0;
|
||||
double t = now();
|
||||
pid_t pid = fork();
|
||||
if (!pid) {
|
||||
int fd2 = shm_open(name, O_RDWR, 0644);
|
||||
int *p = map_page(fd2, 1);
|
||||
for (int i = 0; i < rounds; i++) {
|
||||
int *ping = &p[48], *pong = &p[52];
|
||||
while (__atomic_load_n(ping, __ATOMIC_SEQ_CST) == i * 2) { int v = i * 2; waitv(&ping, &v, 1, NULL, 0); }
|
||||
__atomic_store_n(pong, i * 2 + 2, __ATOMIC_SEQ_CST);
|
||||
wake(pong);
|
||||
}
|
||||
_exit(0);
|
||||
}
|
||||
for (int i = 0; i < rounds; i++) {
|
||||
int *ping = &page[48], *pong = &page[52];
|
||||
__atomic_store_n(ping, i * 2 + 2, __ATOMIC_SEQ_CST);
|
||||
wake(ping);
|
||||
while (__atomic_load_n(pong, __ATOMIC_SEQ_CST) == i * 2) { int v = i * 2; waitv(&pong, &v, 1, NULL, 0); }
|
||||
}
|
||||
waitpid(pid, NULL, 0);
|
||||
printf("pingpong %.2f us/round\n", (now() - t) * 1e6 / rounds);
|
||||
(void)z;
|
||||
}
|
||||
{
|
||||
pthread_t c[4], p[4];
|
||||
sems = &page[256];
|
||||
for (int i = 0; i < 4; i++) pthread_create(&c[i], NULL, consumer, NULL);
|
||||
for (int i = 0; i < 4; i++) pthread_create(&p[i], NULL, producer, (void *)(uintptr_t)(i + 1));
|
||||
for (int i = 0; i < 4; i++) pthread_join(p[i], NULL);
|
||||
for (int i = 0; i < 4; i++) pthread_join(c[i], NULL);
|
||||
CHECK(taken == 4 * ROUNDS && given == 4 * ROUNDS, "stress taken %d given %d", taken, given);
|
||||
for (int i = 0; i < SEMS; i++) CHECK(sems[i * 4] == 0, "sem %d left %d", i, sems[i * 4]);
|
||||
}
|
||||
for (int round = 0; round < 3; round++) {
|
||||
pid_t kids[40];
|
||||
int z = 0;
|
||||
for (int i = 0; i < 40; i++) {
|
||||
__atomic_store_n(&page[24], 0, __ATOMIC_SEQ_CST);
|
||||
kids[i] = fork();
|
||||
if (!kids[i]) { execl("/proc/self/exe", argv[0], "sleeper", name, (char *)NULL); _exit(3); }
|
||||
int *r = &page[24];
|
||||
while (!__atomic_load_n(r, __ATOMIC_SEQ_CST)) waitv(&r, &z, 1, NULL, 0);
|
||||
}
|
||||
for (int i = 0; i < 40; i++) { kill(kids[i], SIGKILL); waitpid(kids[i], NULL, 0); }
|
||||
double t = now();
|
||||
for (int i = 0; i < 1000; i++) wake(&page[20]);
|
||||
CHECK(now() - t < 2.0, "wakes after killed sleepers took %.3f", now() - t);
|
||||
}
|
||||
{
|
||||
pthread_t churners[2], t;
|
||||
int rescued = 0, threads = 3000;
|
||||
double t0 = now();
|
||||
churn_fd = fd;
|
||||
for (int i = 0; i < 2; i++) pthread_create(&churners[i], NULL, churn, NULL);
|
||||
for (int i = 0; i < threads; i++) {
|
||||
void *res;
|
||||
__atomic_store_n(&page[64], 0, __ATOMIC_SEQ_CST);
|
||||
pthread_create(&t, NULL, one_wait, NULL);
|
||||
if (i & 1) usleep(50);
|
||||
__atomic_store_n(&page[64], 1, __ATOMIC_SEQ_CST);
|
||||
wake(&page[64]);
|
||||
pthread_join(t, &res);
|
||||
rescued += (int)(intptr_t)res;
|
||||
}
|
||||
churn_stop = 1;
|
||||
for (int i = 0; i < 2; i++) pthread_join(churners[i], NULL);
|
||||
printf("thread churn %.2f s, %d of %d waits needed the nap\n", now() - t0, rescued, threads);
|
||||
CHECK(rescued <= 3 && now() - t0 < 30, "thread churn: %d naps in %.2f s", rescued, now() - t0);
|
||||
usleep(1100000);
|
||||
__atomic_store_n(&page[64], 0, __ATOMIC_SEQ_CST);
|
||||
pthread_create(&t, NULL, one_wait, NULL);
|
||||
usleep(20000);
|
||||
__atomic_store_n(&page[64], 1, __ATOMIC_SEQ_CST);
|
||||
wake(&page[64]);
|
||||
pthread_join(t, NULL);
|
||||
CHECK(used_slots() == 1, "registry slots still in use: %d", used_slots());
|
||||
}
|
||||
{
|
||||
char reg[96];
|
||||
struct stat st;
|
||||
snprintf(reg, sizeof(reg), "/dev/shm%s-droiddeck", name);
|
||||
shm_unlink(name);
|
||||
CHECK(stat(reg, &st) != 0, "registry left behind");
|
||||
}
|
||||
printf("fsync emulation ok\n");
|
||||
return 0;
|
||||
}
|
||||
"""
|
||||
|
||||
|
||||
@unittest.skipUnless(shutil.which("cc") and os.path.exists("/dev/shm"), "a C compiler and /dev/shm are needed")
|
||||
class FsyncPreloadTest(unittest.TestCase):
|
||||
@classmethod
|
||||
def setUpClass(cls):
|
||||
cls.tmp = tempfile.TemporaryDirectory()
|
||||
base = Path(cls.tmp.name)
|
||||
cls.lib = base / "libfsync.so"
|
||||
cls.exe = base / "fsync-test"
|
||||
source = base / "fsync-test.c"
|
||||
source.write_text(PROGRAM)
|
||||
subprocess.run(["cc", "-O2", "-Wall", "-fPIC", "-shared", "-pthread", "-o", str(cls.lib),
|
||||
str(PRELOAD / "fsync.c"), str(PRELOAD / "robust.c"), "-ldl"], check=True)
|
||||
subprocess.run(["cc", "-O2", "-Wall", "-pthread", "-o", str(cls.exe), str(source)], check=True)
|
||||
|
||||
@classmethod
|
||||
def tearDownClass(cls):
|
||||
cls.tmp.cleanup()
|
||||
|
||||
def run_program(self, **env):
|
||||
return subprocess.run([str(self.exe)], env=dict(os.environ, LD_PRELOAD=str(self.lib), **env),
|
||||
capture_output=True, text=True, timeout=120)
|
||||
|
||||
def test_emulated_waits_wake_time_out_and_survive_dead_waiters(self):
|
||||
result = self.run_program(BL_FSYNC="1")
|
||||
self.assertEqual(result.returncode, 0, result.stdout + result.stderr)
|
||||
self.assertIn("fsync emulation ok", result.stdout)
|
||||
self.assertIn("droiddeck-fsync: up and running.", result.stderr)
|
||||
|
||||
def test_off_without_the_switch(self):
|
||||
result = self.run_program(BL_FSYNC="0")
|
||||
self.assertNotIn("droiddeck-fsync", result.stderr)
|
||||
self.assertNotIn("fsync emulation ok", result.stdout)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
@@ -1,5 +1,6 @@
|
||||
import json
|
||||
import os
|
||||
import shutil
|
||||
from pathlib import Path
|
||||
import runpy
|
||||
import subprocess
|
||||
@@ -8,8 +9,20 @@ import tempfile
|
||||
import unittest
|
||||
|
||||
BIN = Path(__file__).resolve().parents[1] / "linuxfs/overlay/usr/local/bin"
|
||||
MODULE = runpy.run_path(str(BIN / "bannerlator-game-env"))
|
||||
COMPAT = runpy.run_path(str(BIN / "bannerlator-steam-compat"))
|
||||
MODULE = runpy.run_path(str(BIN / "droiddeck-game-env"))
|
||||
COMPAT = runpy.run_path(str(BIN / "steam-compatibility"))
|
||||
STATE = tempfile.TemporaryDirectory()
|
||||
COMPAT["main"].__globals__["COMPAT_DIR"] = STATE.name
|
||||
|
||||
|
||||
def mapping_of(text):
|
||||
tokens = COMPAT["tokenize"](text)
|
||||
return COMPAT["read_mapping"](tokens, COMPAT["mapping_block"](tokens))
|
||||
|
||||
|
||||
def config_text(entries):
|
||||
mapping = "".join('"%s" { "name" "%s" "config" "" "priority" "%s" }' % (app, name, "75" if app == "0" else "250") for app, name in entries)
|
||||
return '"InstallConfigStore" { "Software" { "Valve" { "Steam" { "CompatToolMapping" { %s } } } } }' % mapping
|
||||
|
||||
|
||||
class GameEnvironmentTest(unittest.TestCase):
|
||||
@@ -94,14 +107,14 @@ class GameEnvironmentTest(unittest.TestCase):
|
||||
env = {**os.environ, "HOME": tmp, "STEAM_COMPAT_DATA_PATH": "/compatdata/42"}
|
||||
for value in ("first value", "$(touch " + str(home / "injected") + "); 'literal'=value"):
|
||||
config.write_text(json.dumps({"version": 1, "shared": {"CUSTOM": value}}))
|
||||
result = subprocess.check_output([sys.executable, str(BIN / "bannerlator-game-env"), str(probe), "waitforexitandrun", "path with spaces", "a=b"], env=env, text=True)
|
||||
result = subprocess.check_output([sys.executable, str(BIN / "droiddeck-game-env"), str(probe), "waitforexitandrun", "path with spaces", "a=b"], env=env, text=True)
|
||||
self.assertEqual(json.loads(result), [value, ["waitforexitandrun", "path with spaces", "a=b"]])
|
||||
self.assertFalse((home / "injected").exists())
|
||||
for verb, prefix in (("run", "/compatdata/42"), ("waitforexitandrun", "/compatdata/0")):
|
||||
output = subprocess.check_output([sys.executable, str(BIN / "bannerlator-game-env"), str(probe), verb], env={**env, "STEAM_COMPAT_DATA_PATH": prefix, "CUSTOM": "original"}, text=True)
|
||||
output = subprocess.check_output([sys.executable, str(BIN / "droiddeck-game-env"), str(probe), verb], env={**env, "STEAM_COMPAT_DATA_PATH": prefix, "CUSTOM": "original"}, text=True)
|
||||
self.assertEqual(json.loads(output)[0], "original")
|
||||
config.write_text("{broken")
|
||||
result = subprocess.run([sys.executable, str(BIN / "bannerlator-game-env"), str(probe), "waitforexitandrun"], env={**env, "CUSTOM": "original"}, text=True, capture_output=True, check=True)
|
||||
result = subprocess.run([sys.executable, str(BIN / "droiddeck-game-env"), str(probe), "waitforexitandrun"], env={**env, "CUSTOM": "original"}, text=True, capture_output=True, check=True)
|
||||
self.assertEqual(json.loads(result.stdout)[0], "original")
|
||||
|
||||
def test_generated_valve_and_third_party_launchers_apply_configuration(self):
|
||||
@@ -118,24 +131,332 @@ class GameEnvironmentTest(unittest.TestCase):
|
||||
proton.write_text("#!/usr/bin/python3\nimport json, os, sys\nprint(json.dumps([os.environ['CUSTOM'], sys.argv[1:]]))\nsys.exit(7)\n")
|
||||
proton.chmod(0o755)
|
||||
(extra / "toolmanifest.vdf").write_text('"manifest" { "commandline" "/proton %verb%" }')
|
||||
COMPAT["build_tool"](str(tools / COMPAT["TOOL"]))
|
||||
COMPAT["build_tool"](str(tools / COMPAT["TOOL"]), str(depot))
|
||||
COMPAT["adopt_extras"](str(tools))
|
||||
config = home / ".config/droiddeck/game-environment.json"
|
||||
config.parent.mkdir(parents=True)
|
||||
config.write_text(json.dumps({"version": 1, "shared": {"CUSTOM": "shared"}, "games": {"42": {"CUSTOM": "specific"}}}))
|
||||
wrappers = (tools / COMPAT["TOOL"] / COMPAT["LAUNCHER"], extra / COMPAT["EXTRA_WRAPPER"])
|
||||
for wrapper in wrappers:
|
||||
wrapper.write_text(wrapper.read_text().replace("/usr/local/bin/bannerlator-game-env", str(BIN / "bannerlator-game-env")))
|
||||
wrapper.write_text(wrapper.read_text().replace("/usr/local/bin/droiddeck-game-env", str(BIN / "droiddeck-game-env")))
|
||||
result = subprocess.run([str(wrapper), "waitforexitandrun", "game with spaces.exe"],
|
||||
env={"PATH": os.defpath, "HOME": tmp, "STEAM_COMPAT_DATA_PATH": "/compatdata/42", "STEAM_COMPAT_CLIENT_INSTALL_PATH": str(steam)},
|
||||
text=True, capture_output=True)
|
||||
self.assertEqual(result.returncode, 7, result.stderr)
|
||||
self.assertEqual(json.loads(result.stdout), ["specific", ["waitforexitandrun", "game with spaces.exe"]])
|
||||
|
||||
def test_default_is_compatible_tool_and_labels_mark_it(self):
|
||||
with tempfile.TemporaryDirectory() as tmp:
|
||||
home = Path(tmp)
|
||||
label = home / "label"
|
||||
label.write_text("Compatible\n")
|
||||
COMPAT["display_name"].__globals__["LABEL_FILE"] = str(label)
|
||||
tools = home / "compatibilitytools.d"
|
||||
extra = tools / "proton-cachyos-11"
|
||||
extra.mkdir(parents=True)
|
||||
(extra / "proton").write_text("")
|
||||
(extra / "toolmanifest.vdf").write_text('"manifest" { "commandline" "/proton %verb%" }')
|
||||
vdf = tools / COMPAT["TOOL"] / "compatibilitytool.vdf"
|
||||
COMPAT["build_tool"](str(tools / COMPAT["TOOL"]), None)
|
||||
self.assertIn('"display_name" "Proton ARM64 (Compatible)"', vdf.read_text())
|
||||
for source in COMPAT["SOURCES"]:
|
||||
COMPAT["build_tool"](str(tools / COMPAT["TOOL"]), str(home / "steamapps/common" / source))
|
||||
self.assertIn('"display_name" "%s ARM64 (Compatible)"' % source.replace(" (ARM64)", ""), vdf.read_text())
|
||||
protect = COMPAT["adopt_extras"](str(tools))
|
||||
self.assertIn('"display_name" "proton-cachyos-11 (Compatible)"', (extra / "compatibilitytool.vdf").read_text())
|
||||
config = home / "config.vdf"
|
||||
mapping = "".join('"%s" { "name" "%s" "config" "" "priority" "%s" }' % entry for entry in (
|
||||
("0", "GE-Proton10-25", "75"), ("42", "proton_experimental_arm64", "250"), ("43", "proton-cachyos-11", "250")))
|
||||
config.write_text('"InstallConfigStore" { "Software" { "Valve" { "Steam" { "CompatToolMapping" { %s } } } } }' % mapping)
|
||||
COMPAT["register_default"](str(config), ["44"], protect=protect)
|
||||
tokens = COMPAT["tokenize"](config.read_text())
|
||||
names = {tokens[i - 1].strip('"'): tokens[i + 2].strip('"') for i in range(1, len(tokens) - 2) if tokens[i] == "{" and tokens[i + 1] == '"name"'}
|
||||
self.assertEqual(names, {"0": COMPAT["TOOL"], "42": COMPAT["TOOL"], "43": "proton-cachyos-11", "44": COMPAT["TOOL"]})
|
||||
|
||||
def test_existing_install_moves_to_new_tool_name(self):
|
||||
with tempfile.TemporaryDirectory() as tmp:
|
||||
home = Path(tmp)
|
||||
(home / "label").write_text("Compatible\n")
|
||||
COMPAT["main"].__globals__["LABEL_FILE"] = str(home / "label")
|
||||
steam = home / "Steam"
|
||||
depot = steam / "steamapps/common" / COMPAT["SOURCES"][0]
|
||||
(depot / "files/bin-arm64").mkdir(parents=True)
|
||||
(steam / "steamapps/appmanifest_42.acf").write_text("")
|
||||
legacy = steam / "compatibilitytools.d" / COMPAT["LEGACY_TOOL"]
|
||||
legacy.mkdir(parents=True)
|
||||
for name in COMPAT["OWN_FILES"]:
|
||||
(legacy / name).write_text("old")
|
||||
(steam / "config").mkdir()
|
||||
config = steam / "config/config.vdf"
|
||||
mapping = "".join('"%s" { "name" "%s" "config" "" "priority" "%s" }' % (app, COMPAT["LEGACY_TOOL"], priority)
|
||||
for app, priority in (("0", "75"), ("42", "250")))
|
||||
config.write_text('"InstallConfigStore" { "Software" { "Valve" { "Steam" { "CompatToolMapping" { %s } } } } }' % mapping)
|
||||
argv = sys.argv
|
||||
try:
|
||||
sys.argv = ["steam-compatibility", str(steam)]
|
||||
COMPAT["main"]()
|
||||
migrated = config.read_text()
|
||||
COMPAT["main"]()
|
||||
finally:
|
||||
sys.argv = argv
|
||||
self.assertFalse(legacy.exists())
|
||||
self.assertIn('"display_name" "Proton Experimental ARM64 (Compatible)"',
|
||||
(steam / "compatibilitytools.d" / COMPAT["TOOL"] / "compatibilitytool.vdf").read_text())
|
||||
self.assertNotIn(COMPAT["LEGACY_TOOL"], migrated)
|
||||
self.assertEqual(migrated.count('"%s"' % COMPAT["TOOL"]), 2)
|
||||
self.assertEqual(config.read_text(), migrated)
|
||||
|
||||
def test_launchers_and_adopted_protons_from_before_the_rename_move_over(self):
|
||||
with tempfile.TemporaryDirectory() as tmp:
|
||||
home = Path(tmp)
|
||||
(home / "label").write_text("Compatible\n")
|
||||
COMPAT["main"].__globals__["LABEL_FILE"] = str(home / "label")
|
||||
tools = home / "compatibilitytools.d"
|
||||
own = tools / COMPAT["TOOL"]
|
||||
own.mkdir(parents=True)
|
||||
for name in ("toolmanifest.vdf", "compatibilitytool.vdf", COMPAT["LEGACY_LAUNCHER"]):
|
||||
(own / name).write_text("old")
|
||||
spare = tools / COMPAT["TOOL_11"]
|
||||
spare.mkdir()
|
||||
for name in ("toolmanifest.vdf", "compatibilitytool.vdf", COMPAT["LEGACY_LAUNCHER"]):
|
||||
(spare / name).write_text("old")
|
||||
extra = tools / "GE-Proton11-7"
|
||||
extra.mkdir()
|
||||
(extra / "proton").write_text("")
|
||||
(extra / "toolmanifest.vdf").write_text('"manifest" { "commandline" "/%s %%verb%%" }' % COMPAT["LEGACY_EXTRA_WRAPPER"])
|
||||
(extra / ("toolmanifest.vdf" + COMPAT["LEGACY_ORIGINAL_SUFFIX"])).write_text('"manifest" { "commandline" "/proton %verb%" }')
|
||||
(extra / COMPAT["LEGACY_EXTRA_WRAPPER"]).write_text("old")
|
||||
COMPAT["build_tool"](str(own), None)
|
||||
COMPAT["remove_tool"](str(spare))
|
||||
self.assertEqual(COMPAT["adopt_extras"](str(tools)), {"GE-Proton11-7": "GE-Proton11-7"})
|
||||
self.assertEqual(sorted(os.listdir(own)), sorted(COMPAT["OWN_FILES"]))
|
||||
self.assertFalse(spare.exists())
|
||||
self.assertEqual(sorted(os.listdir(extra)), sorted(["proton", "toolmanifest.vdf", "compatibilitytool.vdf",
|
||||
COMPAT["EXTRA_WRAPPER"], "toolmanifest.vdf" + COMPAT["ORIGINAL_SUFFIX"]]))
|
||||
self.assertIn("/%s %%verb%%" % COMPAT["EXTRA_WRAPPER"], (extra / "toolmanifest.vdf").read_text())
|
||||
self.assertIn('"/proton %verb%"', (extra / ("toolmanifest.vdf" + COMPAT["ORIGINAL_SUFFIX"])).read_text())
|
||||
self.assertIn('"$here/proton"', (extra / COMPAT["EXTRA_WRAPPER"]).read_text())
|
||||
self.assertIn("GE-Proton11-7", [entry["name"] for entry in COMPAT["tool_catalog"](str(home), None)])
|
||||
|
||||
def test_both_proton_wrappers_call_environment_launcher(self):
|
||||
for script in (COMPAT["LAUNCHER_SH"], COMPAT["EXTRA_WRAPPER_SH"] % "proton"):
|
||||
subprocess.run(["bash", "-n"], input=script, text=True, check=True)
|
||||
self.assertIn('exec ${BL_TASKSET:-} /usr/local/bin/bannerlator-game-env', script)
|
||||
self.assertIn('exec ${BL_TASKSET:-} /usr/local/bin/droiddeck-game-env', script)
|
||||
|
||||
def test_wrappers_preload_the_session_library_before_the_input_shim(self):
|
||||
overlay = "/root/.local/share/Steam/ubuntu12_64/gameoverlayrenderer.so"
|
||||
with tempfile.TemporaryDirectory() as tmp:
|
||||
for name in ("libblsession.so", "libfakeinput.so"):
|
||||
(Path(tmp) / name).write_bytes(b"")
|
||||
for script in (COMPAT["LAUNCHER_SH"], COMPAT["EXTRA_WRAPPER_SH"] % "proton"):
|
||||
start = script.index("for fake in ")
|
||||
block = script[start:script.index("\ndone\n", start) + 6].replace("/usr/local/lib/", tmp + "/")
|
||||
for inherited, expected in (
|
||||
(None, ["libblsession.so", "libfakeinput.so"]),
|
||||
(overlay, ["libblsession.so", "libfakeinput.so", overlay]),
|
||||
(tmp + "/libfakeinput.so:" + overlay, ["libblsession.so", "libfakeinput.so", overlay]),
|
||||
(tmp + "/libblsession.so:" + tmp + "/libfakeinput.so", ["libblsession.so", "libfakeinput.so"])):
|
||||
env = {"PATH": os.defpath}
|
||||
if inherited is not None:
|
||||
env["LD_PRELOAD"] = inherited
|
||||
out = subprocess.run(["bash", "-c", block + 'printf %s "$LD_PRELOAD"'], env=env,
|
||||
capture_output=True, text=True, check=True).stdout
|
||||
self.assertEqual([entry.replace(tmp + "/", "") for entry in out.split(":")], expected, inherited)
|
||||
|
||||
|
||||
class ProtonDefaultTest(unittest.TestCase):
|
||||
TOOL = COMPAT["TOOL"]
|
||||
CATALOG = [
|
||||
{"name": COMPAT["TOOL"], "display": "Proton Experimental ARM64", "dir": "Proton Experimental (ARM64)", "valve": True},
|
||||
{"name": COMPAT["TOOL_11"], "display": "Proton 11.0 ARM64", "dir": "Proton 11.0 (ARM64)", "valve": True},
|
||||
{"name": "GE-Proton11-7", "display": "GE-Proton11-7", "dir": "GE-Proton11-7", "valve": False},
|
||||
]
|
||||
NAMES = [t["name"] for t in CATALOG]
|
||||
|
||||
def plan(self, current, installed, default, auto):
|
||||
return COMPAT["plan_mapping"](current, installed, self.NAMES, default, auto)
|
||||
|
||||
def test_new_installs_and_valve_picks_follow_the_default(self):
|
||||
changes, auto = self.plan({"0": self.TOOL, "10": "proton_experimental", "11": "proton_11_arm64", "12": "GE-Proton11-7", "13": "steamlinuxruntime"},
|
||||
["10", "11", "12", "13", "14"], "GE-Proton11-7", {})
|
||||
self.assertEqual(changes, {"0": "GE-Proton11-7", "10": "GE-Proton11-7", "11": "GE-Proton11-7", "14": "GE-Proton11-7"})
|
||||
self.assertEqual(auto, {"10": "GE-Proton11-7", "11": "GE-Proton11-7", "14": "GE-Proton11-7"})
|
||||
|
||||
def test_titles_following_the_default_move_with_it_and_picks_stay(self):
|
||||
current = {"0": self.TOOL, "10": self.TOOL, "11": "GE-Proton11-7", "12": self.TOOL}
|
||||
auto = {"10": self.TOOL, "11": self.TOOL, "12": self.TOOL}
|
||||
changes, auto = self.plan(current, ["10", "11", "12"], COMPAT["TOOL_11"], auto)
|
||||
self.assertEqual(changes, {"0": COMPAT["TOOL_11"], "10": COMPAT["TOOL_11"], "12": COMPAT["TOOL_11"]})
|
||||
self.assertEqual(auto, {"10": COMPAT["TOOL_11"], "12": COMPAT["TOOL_11"]})
|
||||
|
||||
def test_a_removed_tool_falls_back_to_the_default(self):
|
||||
changes, auto = self.plan({"0": self.TOOL, "10": "GE-Proton10-1", "11": "droiddeck-proton-12-arm64"}, ["10", "11"], self.TOOL, {"10": "GE-Proton10-1"})
|
||||
self.assertEqual(changes, {"10": self.TOOL, "11": self.TOOL})
|
||||
self.assertEqual(auto, {"10": self.TOOL, "11": self.TOOL})
|
||||
|
||||
def test_uninstalled_titles_are_forgotten(self):
|
||||
changes, auto = self.plan({"0": self.TOOL}, [], self.TOOL, {"10": self.TOOL})
|
||||
self.assertEqual((changes, auto), ({}, {}))
|
||||
|
||||
def test_the_last_side_to_change_wins(self):
|
||||
state = {"default": self.TOOL, "applied": 5}
|
||||
default, state = COMPAT["choose_default"]("GE-Proton11-7", state, {"seq": 5, "dir": "Proton 11.0 (ARM64)", "valve": True}, self.CATALOG, now=100)
|
||||
self.assertEqual((default, state["source"], state["seq"]), ("GE-Proton11-7", "steam", 100))
|
||||
default, state = COMPAT["choose_default"]("GE-Proton11-7", state, {"seq": 6, "dir": "Proton 11.0 (ARM64)", "valve": True}, self.CATALOG, now=200)
|
||||
self.assertEqual((default, state["source"], state["seq"], state["applied"]), (COMPAT["TOOL_11"], "app", 200, 6))
|
||||
default, state = COMPAT["choose_default"]("GE-Proton11-7", state, {"seq": 6}, self.CATALOG, adopt_steam=False, now=300)
|
||||
self.assertEqual((default, state["seq"]), (COMPAT["TOOL_11"], 200))
|
||||
default, state = COMPAT["choose_default"]("proton_experimental", state, {"seq": 6}, self.CATALOG, now=300)
|
||||
self.assertEqual(default, COMPAT["TOOL_11"])
|
||||
|
||||
def test_a_request_for_a_missing_tool_is_dropped(self):
|
||||
default, state = COMPAT["choose_default"](self.TOOL, {"default": self.TOOL}, {"seq": 9, "dir": "GE-Proton9-1", "valve": False}, self.CATALOG, now=1)
|
||||
self.assertEqual((default, state["applied"]), (self.TOOL, 9))
|
||||
default, state = COMPAT["choose_default"]("GE-Proton11-7", state, {"seq": 9, "dir": "GE-Proton9-1", "valve": False}, self.CATALOG, now=2)
|
||||
self.assertEqual(default, "GE-Proton11-7")
|
||||
|
||||
def test_settle_before_the_client_starts(self):
|
||||
with tempfile.TemporaryDirectory() as tmp:
|
||||
config = Path(tmp) / "config.vdf"
|
||||
config.write_text(config_text([("0", self.TOOL), ("10", "proton_experimental"), ("11", "GE-Proton11-7")]))
|
||||
(Path(tmp) / "request.json").write_text(json.dumps({"seq": 3, "dir": "Proton 11.0 (ARM64)", "valve": True}))
|
||||
default = COMPAT["register_default"](str(config), ["10", "11", "12"], catalog=self.CATALOG, directory=tmp, settle=True)
|
||||
self.assertEqual(default, COMPAT["TOOL_11"])
|
||||
self.assertEqual(mapping_of(config.read_text()), {"0": COMPAT["TOOL_11"], "10": COMPAT["TOOL_11"], "11": "GE-Proton11-7", "12": COMPAT["TOOL_11"]})
|
||||
state = json.loads((Path(tmp) / "state.json").read_text())
|
||||
self.assertEqual((state["applied"], state["source"], state["tools"]), (3, "app", self.CATALOG))
|
||||
config.write_text(config_text([("0", "GE-Proton11-7"), ("10", COMPAT["TOOL_11"]), ("11", "GE-Proton11-7"), ("12", COMPAT["TOOL_11"])]))
|
||||
default = COMPAT["register_default"](str(config), ["10", "11", "12"], catalog=self.CATALOG, directory=tmp, settle=True)
|
||||
self.assertEqual(default, "GE-Proton11-7")
|
||||
self.assertEqual(mapping_of(config.read_text())["10"], "GE-Proton11-7")
|
||||
self.assertEqual(json.loads((Path(tmp) / "state.json").read_text())["source"], "steam")
|
||||
config.write_text(config_text([("0", "proton_experimental")]))
|
||||
default = COMPAT["register_default"](str(config), ["10"], catalog=self.CATALOG, directory=tmp)
|
||||
self.assertEqual(mapping_of(config.read_text()), {"0": "GE-Proton11-7", "10": "GE-Proton11-7"})
|
||||
|
||||
def test_the_shortcut_writer_keeps_the_chosen_default(self):
|
||||
with tempfile.TemporaryDirectory() as tmp:
|
||||
steam = Path(tmp) / "Steam"
|
||||
for name in COMPAT["SOURCES"]:
|
||||
(steam / "steamapps/common" / name / "files/bin-arm64").mkdir(parents=True)
|
||||
(steam / "config").mkdir()
|
||||
config = steam / "config/config.vdf"
|
||||
config.write_text(config_text([("0", COMPAT["TOOL_11"]), ("10", COMPAT["TOOL_11"]), ("3044416433", COMPAT["TOOL_11"])]))
|
||||
(Path(tmp) / "state.json").write_text(json.dumps({"default": COMPAT["TOOL_11"], "auto": {"10": COMPAT["TOOL_11"], "3044416433": COMPAT["TOOL_11"]}}))
|
||||
COMPAT["register_default"](str(config), apps=["3044416433", "3212965118"], protect={}, directory=tmp)
|
||||
self.assertEqual(mapping_of(config.read_text()), {"0": COMPAT["TOOL_11"], "10": COMPAT["TOOL_11"], "3044416433": COMPAT["TOOL_11"], "3212965118": COMPAT["TOOL_11"]})
|
||||
|
||||
def test_each_valve_depot_gets_its_own_tool(self):
|
||||
with tempfile.TemporaryDirectory() as tmp:
|
||||
steam = Path(tmp) / "Steam"
|
||||
for name in COMPAT["SOURCES"]:
|
||||
(steam / "steamapps/common" / name / "files/bin-arm64").mkdir(parents=True)
|
||||
self.assertEqual(COMPAT["find_source"](str(steam), COMPAT["OWN_TOOLS"][1][1]), str(steam / "steamapps/common/Proton 11.0 (ARM64)"))
|
||||
self.assertEqual(COMPAT["find_source"](str(steam)), str(steam / "steamapps/common/Proton Experimental (ARM64)"))
|
||||
self.assertEqual([(t["name"], t["dir"]) for t in COMPAT["tool_catalog"](str(steam), {})],
|
||||
[(COMPAT["TOOL"], "Proton Experimental (ARM64)"), (COMPAT["TOOL_11"], "Proton 11.0 (ARM64)")])
|
||||
for name, sources in COMPAT["OWN_TOOLS"]:
|
||||
COMPAT["build_tool"](str(steam / "compatibilitytools.d" / name), COMPAT["find_source"](str(steam), sources), sources, name)
|
||||
self.assertEqual(COMPAT["adopt_extras"](str(steam / "compatibilitytools.d")), {})
|
||||
self.assertEqual(sorted(os.listdir(steam / "compatibilitytools.d" / COMPAT["TOOL_11"])), sorted(COMPAT["OWN_FILES"]))
|
||||
launcher = COMPAT["launcher_sh"](COMPAT["OWN_TOOLS"][1][1])
|
||||
self.assertIn('for name in "Proton 11.0 (ARM64)"; do', launcher)
|
||||
self.assertIn("${major%%.*}", launcher)
|
||||
|
||||
|
||||
|
||||
class DirectAudioPrefixTest(unittest.TestCase):
|
||||
def setUp(self):
|
||||
self.tmp = tempfile.TemporaryDirectory()
|
||||
self.addCleanup(self.tmp.cleanup)
|
||||
base = Path(self.tmp.name)
|
||||
self.tool = base / "tool"
|
||||
(self.tool / "files/bin-arm64").mkdir(parents=True)
|
||||
wine = self.tool / "files/bin-arm64/wine"
|
||||
wine.write_text("#!/bin/sh\necho wine-11.0-4c8f2e1 '(Staging)'\n")
|
||||
wine.chmod(0o755)
|
||||
self.audio = base / "directaudio"
|
||||
for arch in ("aarch64-windows", "i386-windows", "aarch64-unix"):
|
||||
(self.audio / "lib/wine" / arch).mkdir(parents=True)
|
||||
(self.audio / "lib/wine/aarch64-windows/winedirectaudio.drv").write_bytes(b"arm64x")
|
||||
(self.audio / "lib/wine/i386-windows/winedirectaudio.drv").write_bytes(b"i386")
|
||||
self.compat = base / "compat"
|
||||
self.windows = self.compat / "pfx/drive_c/windows"
|
||||
for folder in ("system32", "syswow64"):
|
||||
(self.windows / folder).mkdir(parents=True)
|
||||
self.reg = self.compat / "pfx/user.reg"
|
||||
|
||||
def run_setup(self):
|
||||
script = COMPAT["BL_DIRECTAUDIO_SETUP"] + '\nbl_directaudio "$1"\necho "WINEDLLPATH=$WINEDLLPATH"\n'
|
||||
env = dict(os.environ, BL_DIRECTAUDIO=str(self.audio), STEAM_COMPAT_DATA_PATH=str(self.compat))
|
||||
env.pop("WINEDLLPATH", None)
|
||||
return subprocess.run(["bash", "-c", script, "bash", str(self.tool)], env=env, capture_output=True, text=True, check=True)
|
||||
|
||||
def audio_values(self):
|
||||
found, current = [], None
|
||||
for line in self.reg.read_text().splitlines():
|
||||
if line.startswith("["):
|
||||
current = line.rsplit("] ", 1)[0] + "]"
|
||||
elif line.startswith('"Audio"='):
|
||||
found.append((current, line))
|
||||
return found
|
||||
|
||||
def link(self, folder):
|
||||
path = self.windows / folder / "winedirectaudio.drv"
|
||||
return os.readlink(path) if path.is_symlink() else None
|
||||
|
||||
def test_the_driver_is_placed_and_selected_the_way_wine_reads_it(self):
|
||||
self.reg.write_text("WINE REGISTRY Version 2\n;; All keys relative to \\\\User\\\\S-1-5-21-0-0-0-1000\n\n#arch=win64\n")
|
||||
result = self.run_setup()
|
||||
self.assertIn("DirectAudio selected", result.stderr)
|
||||
self.assertIn("WINEDLLPATH=%s/lib/wine" % self.audio, result.stdout)
|
||||
self.assertEqual(self.link("system32"), str(self.audio / "lib/wine/aarch64-windows/winedirectaudio.drv"))
|
||||
self.assertEqual(self.link("syswow64"), str(self.audio / "lib/wine/i386-windows/winedirectaudio.drv"))
|
||||
self.assertEqual((self.windows / "system32/winedirectaudio.drv").read_bytes(), b"arm64x")
|
||||
self.assertEqual(self.audio_values(), [("[Software\\\\Wine\\\\Drivers]", '"Audio"="directaudio,pulse"')])
|
||||
before = self.reg.read_text()
|
||||
self.assertNotIn("DirectAudio selected", self.run_setup().stderr)
|
||||
self.assertEqual(self.reg.read_text(), before)
|
||||
self.assertEqual(sorted(os.listdir(self.windows / "system32")), ["winedirectaudio.drv"])
|
||||
|
||||
def test_older_selections_are_upgraded(self):
|
||||
self.reg.write_text('WINE REGISTRY Version 2\n\n[SoftwareWineDrivers] 1790995967\n#time=1dd52e24550e980\n"Audio"="directaudio"\n'
|
||||
'\n[Software\\\\Wine\\\\Drivers] 1790995986\n#time=1dd52e250b31ec4\n"Audio"="directaudio"\n')
|
||||
self.assertIn("DirectAudio selected", self.run_setup().stderr)
|
||||
self.assertEqual(self.audio_values(), [("[SoftwareWineDrivers]", '"Audio"="directaudio"'),
|
||||
("[Software\\\\Wine\\\\Drivers]", '"Audio"="directaudio"'),
|
||||
("[Software\\\\Wine\\\\Drivers]", '"Audio"="directaudio,pulse"')])
|
||||
self.assertNotIn("DirectAudio selected", self.run_setup().stderr)
|
||||
|
||||
def test_a_copied_driver_is_replaced_by_the_staged_one(self):
|
||||
self.reg.write_text("WINE REGISTRY Version 2\n")
|
||||
(self.windows / "system32/winedirectaudio.drv").write_bytes(b"stale copy")
|
||||
self.run_setup()
|
||||
self.assertEqual(self.link("system32"), str(self.audio / "lib/wine/aarch64-windows/winedirectaudio.drv"))
|
||||
|
||||
def test_nothing_is_selected_without_the_driver_in_the_prefix(self):
|
||||
self.reg.write_text("WINE REGISTRY Version 2\n")
|
||||
shutil.rmtree(self.windows)
|
||||
self.assertIn("could not be placed", self.run_setup().stderr)
|
||||
self.assertEqual(self.audio_values(), [])
|
||||
(self.windows / "system32").mkdir(parents=True)
|
||||
(self.audio / "lib/wine/aarch64-windows/winedirectaudio.drv").unlink()
|
||||
self.assertIn("could not be placed", self.run_setup().stderr)
|
||||
self.assertEqual(self.audio_values(), [])
|
||||
|
||||
def test_a_new_prefix_waits_for_the_next_launch(self):
|
||||
shutil.rmtree(self.compat / "pfx")
|
||||
self.assertIn("no prefix yet", self.run_setup().stderr)
|
||||
self.assertFalse(self.reg.exists())
|
||||
|
||||
def test_another_wine_major_is_left_alone(self):
|
||||
(self.tool / "files/bin-arm64/wine").write_text("#!/bin/sh\necho wine-10.0\n")
|
||||
self.reg.write_text("WINE REGISTRY Version 2\n")
|
||||
result = self.run_setup()
|
||||
self.assertIn("left off", result.stderr)
|
||||
self.assertIn("WINEDLLPATH=\n", result.stdout)
|
||||
self.assertEqual(self.audio_values(), [])
|
||||
self.assertIsNone(self.link("system32"))
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
|
||||
@@ -14,7 +14,7 @@ try:
|
||||
except ImportError:
|
||||
Gio = GLib = None
|
||||
|
||||
SCRIPT = Path(__file__).resolve().parents[1] / "linuxfs/overlay/usr/local/bin/bannerlator-login1"
|
||||
SCRIPT = Path(__file__).resolve().parents[1] / "linuxfs/overlay/usr/local/bin/droiddeck-login1"
|
||||
NAME = "org.freedesktop.login1"
|
||||
ROOT = "/org/freedesktop/login1"
|
||||
IFACE = NAME + ".Manager"
|
||||
|
||||
@@ -20,7 +20,7 @@ try:
|
||||
except ImportError:
|
||||
Gio = GLib = None
|
||||
|
||||
SCRIPT = Path(__file__).resolve().parents[1] / "linuxfs/overlay/usr/local/bin/bannerlator-netmanager"
|
||||
SCRIPT = Path(__file__).resolve().parents[1] / "linuxfs/overlay/usr/local/bin/droiddeck-netmanager"
|
||||
if Gio:
|
||||
loader = importlib.machinery.SourceFileLoader("netmanager", str(SCRIPT))
|
||||
spec = importlib.util.spec_from_loader(loader.name, loader)
|
||||
|
||||
@@ -0,0 +1,52 @@
|
||||
import runpy
|
||||
import shutil
|
||||
import tempfile
|
||||
import unittest
|
||||
from pathlib import Path
|
||||
|
||||
COMPAT = runpy.run_path(str(Path(__file__).resolve().parents[1] / "linuxfs/overlay/usr/local/bin/steam-compatibility"))
|
||||
|
||||
|
||||
class RequestFexTest(unittest.TestCase):
|
||||
def setUp(self):
|
||||
self.root = Path(tempfile.mkdtemp())
|
||||
self.addCleanup(shutil.rmtree, self.root, True)
|
||||
(self.root / "steamapps").mkdir()
|
||||
client = self.root / "steamrtarm64/steam"
|
||||
client.parent.mkdir()
|
||||
self.log = self.root / "client.log"
|
||||
client.write_text("#!/bin/sh\necho \"start $1\" >> %s\nsleep 0.3\necho \"end $1\" >> %s\n" % (self.log, self.log))
|
||||
client.chmod(0o755)
|
||||
|
||||
def install(self, app):
|
||||
(self.root / ("steamapps/appmanifest_%s.acf" % app)).write_text("")
|
||||
|
||||
def test_one_install_is_asked_for_at_a_time(self):
|
||||
asked = set()
|
||||
self.assertEqual(["3127680"], COMPAT["request_fex"](str(self.root), asked))
|
||||
self.assertEqual(["start steam://install/3127680", "end steam://install/3127680"], self.log.read_text().splitlines())
|
||||
self.assertEqual([], COMPAT["request_fex"](str(self.root), asked))
|
||||
self.install("3127680")
|
||||
self.assertEqual(["1628350"], COMPAT["request_fex"](str(self.root), asked))
|
||||
self.assertEqual(["start steam://install/3127680", "end steam://install/3127680",
|
||||
"start steam://install/1628350", "end steam://install/1628350"],
|
||||
self.log.read_text().splitlines())
|
||||
self.install("1628350")
|
||||
self.assertEqual([], COMPAT["request_fex"](str(self.root), asked))
|
||||
self.assertEqual({"3127680", "1628350"}, asked)
|
||||
|
||||
def test_a_declined_install_is_not_asked_again_in_the_same_session(self):
|
||||
asked = set()
|
||||
self.assertEqual(["3127680"], COMPAT["request_fex"](str(self.root), asked))
|
||||
self.assertEqual([], COMPAT["request_fex"](str(self.root), asked))
|
||||
self.assertEqual(["3127680"], COMPAT["request_fex"](str(self.root), set()))
|
||||
|
||||
def test_only_what_is_missing_is_asked_for_once(self):
|
||||
self.install("3127680")
|
||||
asked = set()
|
||||
self.assertEqual(["1628350"], COMPAT["request_fex"](str(self.root), asked))
|
||||
self.assertEqual([], COMPAT["request_fex"](str(self.root), asked))
|
||||
self.assertEqual(["start steam://install/1628350", "end steam://install/1628350"], self.log.read_text().splitlines())
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
@@ -17,11 +17,11 @@ class SessionAssetsTest(unittest.TestCase):
|
||||
self.addCleanup(self.temp.cleanup)
|
||||
self.root = Path(self.temp.name)
|
||||
self.overlay = self.root / 'overlay'
|
||||
self.helper = self.overlay / 'usr/local/bin/bannerlator-login1'
|
||||
self.helper = self.overlay / 'usr/local/bin/droiddeck-login1'
|
||||
self.helper.parent.mkdir(parents=True)
|
||||
self.helper.write_bytes(b'current helper')
|
||||
self.apk = self.root / 'app.apk'
|
||||
self.name = 'assets/linuxfs/usr/local/bin/bannerlator-login1'
|
||||
self.name = 'assets/linuxfs/usr/local/bin/droiddeck-login1'
|
||||
|
||||
def test_missing_required_helper_rejects_cached_bundle(self):
|
||||
with ZipFile(self.apk, 'w') as package:
|
||||
|
||||
@@ -0,0 +1,39 @@
|
||||
import re
|
||||
import shutil
|
||||
import subprocess
|
||||
import tempfile
|
||||
import unittest
|
||||
from pathlib import Path
|
||||
|
||||
SESSION = Path(__file__).resolve().parents[1] / "linuxfs/overlay/usr/local/bin/droiddeck-session"
|
||||
|
||||
|
||||
def log_redirect():
|
||||
match = re.search(r"^\s*(exec > >\(.*\) 2>&1)$", SESSION.read_text(), re.M)
|
||||
return match.group(1)
|
||||
|
||||
|
||||
class SessionLogTest(unittest.TestCase):
|
||||
def setUp(self):
|
||||
self.tmp = Path(tempfile.mkdtemp())
|
||||
self.addCleanup(shutil.rmtree, self.tmp, True)
|
||||
self.log = self.tmp / "session.log"
|
||||
|
||||
def run_session(self, body, cap=None):
|
||||
script = "BL_LOG=%s\n%s%s\n%s\n" % (self.log, "BL_LOG_CAP=%d\n" % cap if cap else "", log_redirect(), body)
|
||||
subprocess.run(["bash", "-c", script], timeout=30, check=False)
|
||||
|
||||
def test_the_last_lines_survive_the_writer_being_killed(self):
|
||||
self.run_session('for i in $(seq 1 60); do echo "line $i"; done\nsleep 0.5\n'
|
||||
'for p in $(pgrep -P $$); do kill -9 $(pgrep -P $p) $p 2>/dev/null; done')
|
||||
lines = self.log.read_text().splitlines()
|
||||
self.assertEqual(60, len(lines))
|
||||
self.assertEqual("line 60", lines[-1])
|
||||
|
||||
def test_the_log_keeps_its_first_bytes_and_drains_the_rest(self):
|
||||
self.run_session("printf 'abcdefghij\\nklmnop\\n'\nsleep 0.5", cap=5)
|
||||
self.assertEqual("abcde", self.log.read_text())
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
@@ -0,0 +1,218 @@
|
||||
import json
|
||||
import os
|
||||
from pathlib import Path
|
||||
import runpy
|
||||
import shutil
|
||||
import subprocess
|
||||
import tempfile
|
||||
import unittest
|
||||
|
||||
BIN = Path(__file__).resolve().parents[1] / "linuxfs/overlay/usr/local/bin"
|
||||
LIVE = runpy.run_path(str(BIN / "droiddeck-steam-compat"))
|
||||
COMPAT = LIVE["COMPAT"]
|
||||
TOOL = COMPAT["TOOL"]
|
||||
TOOL_11 = COMPAT["TOOL_11"]
|
||||
|
||||
FAKE_STEAM = r"""
|
||||
const dec = new TextDecoder(), enc = new TextEncoder();
|
||||
function readVarint(b, at) { let r = 0n, s = 0n, x; do { x = b[at.i++]; r |= BigInt(x & 0x7f) << s; s += 7n; } while (x & 0x80); return r; }
|
||||
function fields(b) {
|
||||
const f = {}, at = { i: 0 };
|
||||
while (at.i < b.length) {
|
||||
const k = Number(readVarint(b, at)), n = k >> 3, w = k & 7; let v;
|
||||
if (w === 0) v = readVarint(b, at);
|
||||
else if (w === 1) { v = 0n; for (let j = 0; j < 8; j++) v |= BigInt(b[at.i + j]) << BigInt(8 * j); at.i += 8; }
|
||||
else if (w === 2) { const len = Number(readVarint(b, at)); v = b.slice(at.i, at.i + len); at.i += len; }
|
||||
else throw new Error("wire " + w);
|
||||
(f[n] = f[n] || []).push(v);
|
||||
}
|
||||
return f;
|
||||
}
|
||||
function vint(n, out) { n = BigInt(n); do { let x = Number(n & 0x7fn); n >>= 7n; if (n) x |= 0x80; out.push(x); } while (n); }
|
||||
function lenField(n, bytes, out) { vint(n * 8 + 2, out); vint(bytes.length, out); for (const x of bytes) out.push(x); }
|
||||
function reply(eresult, jobid, body, name) {
|
||||
const h = [];
|
||||
if (jobid !== null) { vint(11 * 8 + 1, h); let n = jobid; for (let i = 0; i < 8; i++) { h.push(Number(n & 0xffn)); n >>= 8n; } }
|
||||
if (name) lenField(12, enc.encode(name), h);
|
||||
vint(13 * 8, h); vint(eresult, h);
|
||||
const out = new Uint8Array(8 + h.length + body.length), dv = new DataView(out.buffer);
|
||||
dv.setUint32(0, (0x80000000 | 147) >>> 0, true); dv.setUint32(4, h.length, true);
|
||||
out.set(h, 8); out.set(body, 8 + h.length);
|
||||
return out.buffer;
|
||||
}
|
||||
const state = { mapping: JSON.parse(process.argv[2]), known: JSON.parse(process.argv[3]), log: [], authed: false, notify: [] };
|
||||
class FakeSocket {
|
||||
constructor(url) { this.url = url; this.readyState = 0; state.socket = this; setTimeout(() => { this.readyState = 1; this.onopen(); }, 0); }
|
||||
send(buffer) {
|
||||
const b = new Uint8Array(buffer), dv = new DataView(buffer.buffer || buffer);
|
||||
if (dv.getUint32(0, true) !== ((0x80000000 | 146) >>> 0)) throw new Error("bad emsg");
|
||||
const hl = dv.getUint32(4, true), h = fields(b.slice(8, 8 + hl)), body = fields(b.slice(8 + hl));
|
||||
const method = dec.decode(h[12][0]), jobid = h[10][0];
|
||||
let out = [], result = 1;
|
||||
if (method === "TransportAuth.Authenticate#1") {
|
||||
state.authed = dec.decode(h[40][0]) === "secret" && dec.decode(body[1][0]) === "secret";
|
||||
result = state.authed ? 1 : 5;
|
||||
} else if (!state.authed) result = 5;
|
||||
else if (method === "CompatManager.GetCompatTools#1") {
|
||||
const app = String(body[1] ? body[1][0] : 0n);
|
||||
for (const name of state.known) { const t = []; lenField(1, enc.encode(name), t); lenField(2, enc.encode(name + " shown"), t); lenField(1, t, out); }
|
||||
lenField(3, enc.encode(state.mapping[app] || ""), out);
|
||||
lenField(4, enc.encode("proton_experimental"), out);
|
||||
} else if (method === "CompatManager.SpecifyCompatTool#1") {
|
||||
const app = String(body[1] ? body[1][0] : 0n), name = body[2] ? dec.decode(body[2][0]) : "";
|
||||
state.mapping[app] = name; state.log.push(app + "=" + name);
|
||||
setTimeout(() => this.onmessage({ data: reply(1, null, new Uint8Array(0), "CompatManager.NotifyStateChanged#1") }), 0);
|
||||
} else result = 2;
|
||||
setTimeout(() => this.onmessage({ data: reply(result, jobid, Uint8Array.from(out)) }), 0);
|
||||
}
|
||||
close() {}
|
||||
}
|
||||
globalThis.window = globalThis;
|
||||
globalThis.WebSocket = FakeSocket;
|
||||
globalThis.SteamClient = { WebUITransport: { GetTransportInfo: async () => ({ portClientdll: 4242, authKeyClientdll: "secret" }) } };
|
||||
window.droiddeckCompatChanged = (n) => state.notify.push(n);
|
||||
const install = require("fs").readFileSync(process.argv[4], "utf8");
|
||||
(async () => {
|
||||
if (eval(install) !== "installed" || eval(install) !== "present") throw new Error("install is not idempotent");
|
||||
const c = window.__droiddeckCompat;
|
||||
const before = await c.get(0);
|
||||
await c.set(0, "droiddeck-proton-11-arm64");
|
||||
await c.set(42, "");
|
||||
const after = await c.many(["0", "42", "43"]);
|
||||
await new Promise((r) => setTimeout(r, 10));
|
||||
console.log(JSON.stringify({ before, after, log: state.log, notify: state.notify, url: state.socket.url }));
|
||||
})().catch((e) => { console.error(e.stack || String(e)); process.exit(1); });
|
||||
"""
|
||||
|
||||
|
||||
class FakePage:
|
||||
def __init__(self, mapping, known):
|
||||
self.mapping = dict(mapping)
|
||||
self.known = list(known)
|
||||
self.sets = []
|
||||
|
||||
def compat(self, call):
|
||||
name, _, args = call.partition("(")
|
||||
args = json.loads("[%s]" % args[:-1])
|
||||
if name == "get":
|
||||
return {"selected": self.mapping.get(str(args[0]), ""), "fallback": "proton_experimental", "tools": self.known}
|
||||
if name == "many":
|
||||
return {app: self.mapping.get(app, "") for app in args[0]}
|
||||
if name == "set":
|
||||
self.mapping[str(args[0])] = args[1]
|
||||
self.sets.append((str(args[0]), args[1]))
|
||||
return True
|
||||
raise AssertionError(call)
|
||||
|
||||
|
||||
@unittest.skipUnless(shutil.which("node"), "node is not installed")
|
||||
class PageScriptTest(unittest.TestCase):
|
||||
def test_transport_framing_auth_and_notifications(self):
|
||||
with tempfile.TemporaryDirectory() as tmp:
|
||||
script = Path(tmp) / "install.js"
|
||||
script.write_text(LIVE["INSTALL_JS"])
|
||||
harness = Path(tmp) / "harness.js"
|
||||
harness.write_text(FAKE_STEAM)
|
||||
result = subprocess.run(["node", str(harness), json.dumps({"0": TOOL, "42": "proton_experimental"}),
|
||||
json.dumps([TOOL, TOOL_11, "proton_experimental"]), str(script)],
|
||||
capture_output=True, text=True, timeout=60)
|
||||
self.assertEqual(result.returncode, 0, result.stderr)
|
||||
out = json.loads(result.stdout)
|
||||
self.assertEqual(out["url"], "ws://127.0.0.1:4242/transportsocket/")
|
||||
self.assertEqual(out["before"], {"selected": TOOL, "fallback": "proton_experimental", "tools": [TOOL, TOOL_11, "proton_experimental"]})
|
||||
self.assertEqual(out["after"], {"0": TOOL_11, "42": "", "43": ""})
|
||||
self.assertEqual(out["log"], ["0=" + TOOL_11, "42="])
|
||||
self.assertEqual(out["notify"], ["1", "2"])
|
||||
|
||||
|
||||
class DevtoolsHttpTest(unittest.TestCase):
|
||||
def test_a_kept_alive_answer_is_read_to_its_length(self):
|
||||
import socket
|
||||
import threading
|
||||
server = socket.socket()
|
||||
server.bind(("127.0.0.1", 0))
|
||||
server.listen(1)
|
||||
port = server.getsockname()[1]
|
||||
body = json.dumps([{"title": "other"}, {"title": "SharedJSContext", "webSocketDebuggerUrl": "ws://127.0.0.1:%d/devtools/page/AB" % port}]).encode()
|
||||
done = threading.Event()
|
||||
|
||||
def answer():
|
||||
conn, _ = server.accept()
|
||||
conn.recv(4096)
|
||||
conn.sendall(b"HTTP/1.1 200 OK\r\nContent-Length: %d\r\n\r\n" % len(body) + body)
|
||||
done.wait(10)
|
||||
conn.close()
|
||||
server.close()
|
||||
|
||||
thread = threading.Thread(target=answer)
|
||||
thread.start()
|
||||
try:
|
||||
self.assertEqual(LIVE["shared_context"](port), "/devtools/page/AB")
|
||||
finally:
|
||||
done.set()
|
||||
thread.join()
|
||||
|
||||
|
||||
class ReconcileTest(unittest.TestCase):
|
||||
def setUp(self):
|
||||
self.tmp = tempfile.TemporaryDirectory()
|
||||
self.addCleanup(self.tmp.cleanup)
|
||||
base = Path(self.tmp.name)
|
||||
self.steam = base / "Steam"
|
||||
for name in COMPAT["SOURCES"]:
|
||||
(self.steam / "steamapps/common" / name / "files/bin-arm64").mkdir(parents=True)
|
||||
for app in ("10", "11"):
|
||||
(self.steam / ("steamapps/appmanifest_%s.acf" % app)).write_text("")
|
||||
self.state = base / "compat"
|
||||
self.state.mkdir()
|
||||
COMPAT["main"].__globals__["COMPAT_DIR"] = str(self.state)
|
||||
COMPAT["main"].__globals__["LABEL_FILE"] = str(base / "no-label")
|
||||
self.addCleanup(COMPAT["main"].__globals__.__setitem__, "COMPAT_DIR", COMPAT["COMPAT_DIR"])
|
||||
self.helper = LIVE["Helper"](str(self.steam), 1)
|
||||
|
||||
def reconcile(self, page):
|
||||
self.helper.page = page
|
||||
self.helper.reconcile()
|
||||
return json.loads((self.state / "state.json").read_text())
|
||||
|
||||
def test_new_install_gets_the_default_live(self):
|
||||
page = FakePage({"0": TOOL, "10": TOOL, "11": "proton_experimental"}, [TOOL, TOOL_11])
|
||||
state = self.reconcile(page)
|
||||
self.assertEqual(page.sets, [("11", TOOL)])
|
||||
self.assertEqual(state["auto"], {"10": TOOL, "11": TOOL})
|
||||
self.assertTrue(state["live"])
|
||||
self.assertEqual(self.helper.installed, ["10", "11"])
|
||||
|
||||
def test_app_request_moves_the_default_and_followers(self):
|
||||
page = FakePage({"0": TOOL, "10": TOOL, "11": "GE-Proton11-7"}, [TOOL, TOOL_11])
|
||||
(self.state / "state.json").write_text(json.dumps({"default": TOOL, "auto": {"10": TOOL}}))
|
||||
(self.state / "request.json").write_text(json.dumps({"seq": 7, "valve": True, "dir": "Proton 11.0 (ARM64)"}))
|
||||
state = self.reconcile(page)
|
||||
self.assertEqual(page.sets, [("0", TOOL_11), ("10", TOOL_11)])
|
||||
self.assertEqual((state["default"], state["source"], state["applied"]), (TOOL_11, "app", 7))
|
||||
self.assertEqual(page.mapping["11"], "GE-Proton11-7")
|
||||
|
||||
def test_a_steam_menu_change_is_mirrored(self):
|
||||
page = FakePage({"0": TOOL_11, "10": TOOL}, [TOOL, TOOL_11])
|
||||
(self.state / "state.json").write_text(json.dumps({"default": TOOL, "auto": {"10": TOOL}}))
|
||||
state = self.reconcile(page)
|
||||
self.assertEqual((state["default"], state["source"]), (TOOL_11, "steam"))
|
||||
self.assertEqual(page.sets, [("10", TOOL_11), ("11", TOOL_11)])
|
||||
|
||||
def test_a_tool_the_client_has_not_loaded_waits_for_a_restart(self):
|
||||
page = FakePage({"0": TOOL, "10": TOOL, "11": TOOL}, [TOOL])
|
||||
(self.state / "request.json").write_text(json.dumps({"seq": 3, "valve": True, "dir": "Proton 11.0 (ARM64)"}))
|
||||
state = self.reconcile(page)
|
||||
self.assertEqual(page.sets, [])
|
||||
self.assertEqual((state["pending"], state.get("applied", 0)), (TOOL_11, 0))
|
||||
self.assertTrue(self.helper.request_waiting())
|
||||
|
||||
def test_file_mode_defers_to_the_live_helper(self):
|
||||
(self.state / "live.pid").write_text("%d\n" % os.getpid())
|
||||
self.assertTrue(COMPAT["live_helper_running"]())
|
||||
LIVE["detach"]()
|
||||
self.assertFalse(COMPAT["live_helper_running"]())
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
@@ -18,9 +18,9 @@ def load(name):
|
||||
return module
|
||||
|
||||
|
||||
imports = load('bannerlator-steam-games')
|
||||
shortcuts = load('bannerlator-steam-shortcuts')
|
||||
library = load('bannerlator-steam-library')
|
||||
imports = load('droiddeck-steam-games')
|
||||
shortcuts = load('droiddeck-steam-shortcuts')
|
||||
library = load('droiddeck-steam-library')
|
||||
|
||||
|
||||
class ImportsTest(unittest.TestCase):
|
||||
@@ -289,7 +289,7 @@ class ImportsTest(unittest.TestCase):
|
||||
path.write_bytes(original)
|
||||
listing = self.root / 'games.json'
|
||||
listing.write_text(json.dumps([self.game]))
|
||||
run = subprocess.run(['python3', str(BIN / 'bannerlator-steam-shortcuts'), str(self.steam), str(listing)], capture_output=True)
|
||||
run = subprocess.run(['python3', str(BIN / 'droiddeck-steam-shortcuts'), str(self.steam), str(listing)], capture_output=True)
|
||||
self.assertEqual(1, run.returncode)
|
||||
self.assertEqual(original, path.read_bytes())
|
||||
|
||||
@@ -300,7 +300,7 @@ class ImportsTest(unittest.TestCase):
|
||||
path.write_bytes(shortcuts.write({'shortcuts': {'0': manual, '1': shortcuts.shortcut(self.game)}}))
|
||||
listing = self.root / 'games.json'
|
||||
listing.write_text(json.dumps([self.game]))
|
||||
subprocess.run(['python3', str(BIN / 'bannerlator-steam-shortcuts'), str(self.steam), str(listing)], check=True, capture_output=True)
|
||||
subprocess.run(['python3', str(BIN / 'droiddeck-steam-shortcuts'), str(self.steam), str(listing)], check=True, capture_output=True)
|
||||
result = shortcuts.parse(path.read_bytes())['shortcuts']
|
||||
self.assertEqual([manual], list(result.values()))
|
||||
self.assertEqual({str(self.game['appid']): 42}, json.loads((path.parent / '.droiddeck-routes.json').read_text()))
|
||||
|
||||
@@ -8,7 +8,7 @@ import unittest
|
||||
import zipfile
|
||||
|
||||
|
||||
SCRIPT = Path(__file__).resolve().parents[1] / 'linuxfs/overlay/usr/local/bin/bannerlator-steam-install'
|
||||
SCRIPT = Path(__file__).resolve().parents[1] / 'linuxfs/overlay/usr/local/bin/droiddeck-steam-install'
|
||||
|
||||
|
||||
class SteamInstallTest(unittest.TestCase):
|
||||
@@ -64,7 +64,7 @@ cp "$TEST_CDN/${2##*/}" "$4"
|
||||
result = self.install(channel)
|
||||
self.assertEqual(0, result.returncode, result.stderr)
|
||||
self.assertEqual(channel + '\n', (self.steam / 'package/beta').read_text())
|
||||
self.assertEqual('123456\n', (self.steam / 'package/bannerlator-installed').read_text())
|
||||
self.assertEqual('123456\n', (self.steam / 'package/droiddeck-installed').read_text())
|
||||
client = self.steam / 'steamrtarm64/steam'
|
||||
self.assertTrue(os.access(client, os.X_OK))
|
||||
self.assertEqual(channel, client.read_text())
|
||||
@@ -99,7 +99,7 @@ cp "$TEST_CDN/${2##*/}" "$4"
|
||||
original = archive.read_bytes()
|
||||
archive.write_bytes(b'corrupt download')
|
||||
self.assertNotEqual(0, self.install('publicbeta').returncode)
|
||||
self.assertFalse((self.steam / 'package/bannerlator-installed').exists())
|
||||
self.assertFalse((self.steam / 'package/droiddeck-installed').exists())
|
||||
archive.write_bytes(original)
|
||||
self.assertEqual(0, self.install('publicbeta').returncode)
|
||||
self.assertEqual('publicbeta\n', (self.steam / 'package/beta').read_text())
|
||||
|
||||
@@ -5,7 +5,7 @@ import unittest
|
||||
|
||||
|
||||
BIN = Path(__file__).resolve().parents[1] / 'linuxfs/overlay/usr/local/bin'
|
||||
MODULE = runpy.run_path(str(BIN / 'bannerlator-steam-ui-scale'))
|
||||
MODULE = runpy.run_path(str(BIN / 'droiddeck-steam-ui-scale'))
|
||||
initialize = MODULE['initialize']
|
||||
seed_text = MODULE['seed_text']
|
||||
parse = MODULE['parse']
|
||||
|
||||
Reference in new issue
Block a user