mirror of
https://github.com/Droid-Deck/DroidDeck.git
synced 2026-11-21 05:46:03 +00:00
* Steam x86-64 client: menus come up, sign-in stays put, games listed once
Switching the Steam client from arm64 to x86-64 left the client on a blank
screen behind "Downloading the Steam client update 100%", and each switch
signed one of the clients out.
- The x86-64 client is Valve's steamrt64 platform, but it was installed and
synced from the ubuntu12 manifest, which lags it (1792108788 against
1792192922). The client was therefore never the arm64 client's build, the
arm64 web helper was never used, and the client then updated itself in
place after the helper had been chosen. Install, sync and the build check
now read the steamrt64 manifest.
- The x86 web helper's GPU process loads libpci, which exits when
/sys/bus/pci/devices lists a device whose files the app may not read (a
RedMagic's PCIe root ports). Every GPU process exited with status 1, even
in software, until Chromium gave up and the menus stayed blank. An empty
folder is bound over /sys/bus/pci/devices on such devices.
- Steam refuses one client's login token from the other ("Invalid
Password" for a token the arm64 client signed in with minutes before), so
copying the newer token at every start signed the other client out. Each
client now keeps its own token; a client with no accounts only gets the
other's account list.
- Games could be listed twice: an added game whose folder a Steam import
already covers is now shown as that Steam game only, a client switch
drops the old client's imported entries, an import stays one when its
ownership cannot be confirmed instead of gaining a shortcut beside it,
and only the client's own library folders count as an install.
* Steam x86-64 client: share the arm64 sign-in again
The x86-64 client refused the arm64 client's login token because it did
not know the account's SteamID: it takes it from Accounts in
config/config.vdf, which this script creates without one. It logged on as
[U:1:0] with a valid token, Steam answered "Invalid Password", and the
client dropped the token and AutoLoginUser, so every switch asked for the
password.
The newer sign-in is copied between the clients again, each start adds
the accounts either client knows to the other's config.vdf, and an
AutoLoginUser or RememberPassword one client lacks is filled in. Device:
the x86 client signs in with the arm64 token on a fresh install and on an
install left signed out, and the arm64 client stays signed in.
1145 lines
50 KiB
Bash
Executable File
1145 lines
50 KiB
Bash
Executable File
#!/bin/bash
|
|
set -eu
|
|
FEX_TAG=fex-2610-r5
|
|
FEX_SHA256=0fc1ca2ba13817ad70d1ea157119a75c9c02446b57d166e6d676cce0807c19c4
|
|
FEX_URL=https://github.com/Droid-Deck/DroidDeck-Components/releases/download/$FEX_TAG/fex.tzst
|
|
ROOTFS_URL=https://github.com/Droid-Deck/DroidDeck-Components/releases/download/fex-rootfs-ubuntu-24.04-2026-08-11/Ubuntu_24_04.sqsh
|
|
ROOTFS_SHA256=2854b06d3ff1b8f6e526135bfb6dd5b7b30ab3ab73e79ae933a3d9fed959a178
|
|
CDN=https://client-update.fastly.steamstatic.com
|
|
# Must match the -clientbeta droiddeck-session starts this client with (steam_channel).
|
|
X64_CHANNEL=steamdeck_publicbeta
|
|
MANIFEST=steam_client_${X64_CHANNEL}_steamrt64
|
|
|
|
REAL_HOME=${HOME:-/root}
|
|
X64_HOME=${BL_X64_HOME:-$REAL_HOME/.droiddeck-x64}
|
|
ROOTFS=$X64_HOME/rootfs
|
|
STEAM_X64=$X64_HOME/.local/share/Steam
|
|
ARM_STEAM=${XDG_DATA_HOME:-$REAL_HOME/.local/share}/Steam
|
|
LOG=$X64_HOME/steam-x64.log
|
|
mkdir -p "$X64_HOME"
|
|
step() { echo "== STEP $(date -u +%H:%M:%S) $*" | tee -a "$LOG"; }
|
|
|
|
x64_default_dir() {
|
|
local d
|
|
while IFS= read -r d; do
|
|
[ -f "$d/.droiddeck-arm64-proton" ] && { echo "$d"; return; }
|
|
done < <(ls -d "$STEAM_X64"/compatibilitytools.d/DroidDeck-Proton* 2>/dev/null | sort -V -r
|
|
ls -d "$STEAM_X64"/compatibilitytools.d/GE-Proton*-aarch64 2>/dev/null | sort -V -r)
|
|
echo "$STEAM_X64/compatibilitytools.d/droiddeck-proton-arm64"
|
|
}
|
|
x64_default_tool() {
|
|
sed -n 's/^[[:space:]]*"\([^"]*\)"[[:space:]]*$/\1/p' "$(x64_default_dir)/compatibilitytool.vdf" 2>/dev/null |
|
|
grep -v -x -e compatibilitytools -e compat_tools | head -n 1
|
|
}
|
|
|
|
x64_client_parts() {
|
|
awk -F'"' '
|
|
/^\t"/ && NF >= 3 && $4 == "" { block = $2 }
|
|
$2 == "file" { file[block] = $4 }
|
|
$2 == "sha2" { sha[block] = $4 }
|
|
END { for (b in file) if (b ~ /_all$/ || b ~ /_steamrt64$/) print b, file[b], sha[b] }
|
|
' "$1" | sort
|
|
}
|
|
|
|
x64_sync_client() {
|
|
local chan cur version work total i block file sum old
|
|
chan=$(cat "$STEAM_X64/package/beta" 2>/dev/null || echo "$X64_CHANNEL")
|
|
old=$STEAM_X64/package/steam_client_${chan}_steamrt64.manifest
|
|
cur=$(awk -F'"' '$2 == "version" { print $4; exit }' "$old" 2>/dev/null || true)
|
|
work=$(mktemp -d)
|
|
if ! curl -fsSL "$CDN/steam_client_${chan}_steamrt64" -o "$work/manifest"; then
|
|
rm -rf "$work"; return 0
|
|
fi
|
|
version=$(awk -F'"' '$2 == "version" { print $4; exit }' "$work/manifest")
|
|
if [ -z "$version" ] || [ "$version" = "$cur" ]; then
|
|
rm -rf "$work"; return 0
|
|
fi
|
|
x64_client_parts "$work/manifest" > "$work/parts"
|
|
if [ -f "$old" ]; then
|
|
x64_client_parts "$old" | awk '{ print $3 }' > "$work/have"
|
|
grep -vwF -f "$work/have" "$work/parts" > "$work/todo" || true
|
|
else
|
|
cp "$work/parts" "$work/todo"
|
|
fi
|
|
total=$(grep -c . "$work/todo" || true)
|
|
step "updating the x86-64 Steam client to $version (was ${cur:-none}, $total part(s))"
|
|
i=0
|
|
while read -r block file sum; do
|
|
i=$((i + 1))
|
|
step "downloading Steam: $block ($i/$total)"
|
|
if ! curl -fsSL "$CDN/$file" -o "$work/$file" || ! echo "$sum $work/$file" | sha256sum -c --quiet; then
|
|
step "could not update the x86-64 client; it updates itself"
|
|
rm -rf "$work"; return 0
|
|
fi
|
|
unzip -qo "$work/$file" -d "$STEAM_X64"
|
|
rm -f "$work/$file"
|
|
done < "$work/todo"
|
|
cp -f "$work/manifest" "$old"
|
|
echo "$version" > "$STEAM_X64/package/droiddeck-installed"
|
|
chmod +x "$STEAM_X64/steam.sh" "$STEAM_X64/steamrt64/steam" "$STEAM_X64/ubuntu12_32/steam" 2>/dev/null || true
|
|
rm -rf "$work"
|
|
}
|
|
|
|
# The client rewrites config.vdf from memory as it exits: the mapping is written only while no x86 client runs.
|
|
x64_map_direct() {
|
|
local mode=write
|
|
[ "${1:-}" = --live ] && mode=live
|
|
[ -f "$STEAM_X64/config/config.vdf" ] || return 0
|
|
if [ "$mode" = write ] && pgrep -f 'steamrt64/steam( |$)' >/dev/null 2>&1; then return 0; fi
|
|
python3 - "$mode" "$STEAM_X64/config/config.vdf" "$STEAM_X64/appcache/appinfo.vdf" "$X64_HOME/direct-auto.json" \
|
|
"$X64_HOME/direct-sniper" "$STEAM_X64/steamapps:/mnt/droiddeck-sd/x86-64/steamapps" "$(x64_default_tool)" \
|
|
"$REAL_HOME/.bl-compat-pending" ${BL_X64_DIRECT_APPS:-550} \
|
|
<<'PY' || { [ "$mode" = live ] || step "could not map titles to DroidDeck direct"; }
|
|
# Steam does not swap an installed build when the tool changes: a title installed for Windows stays on Proton.
|
|
import json, os, re, struct, sys
|
|
mode, path, appinfo, auto_file, sniper_file, steamapps, proton, pending = sys.argv[1:9]
|
|
extra = sys.argv[9:]
|
|
WINDOWS_DEPOTS = {}
|
|
KNOWN = set()
|
|
|
|
|
|
def read_kv(buf, pos, strings):
|
|
out = {}
|
|
while True:
|
|
t = buf[pos]
|
|
pos += 1
|
|
if t == 0x08:
|
|
return out, pos
|
|
if strings is not None:
|
|
key = strings[struct.unpack_from("<I", buf, pos)[0]]
|
|
pos += 4
|
|
else:
|
|
end = buf.index(b"\0", pos)
|
|
key = buf[pos:end].decode("utf-8", "replace")
|
|
pos = end + 1
|
|
if t == 0x00:
|
|
out[key], pos = read_kv(buf, pos, strings)
|
|
elif t == 0x01:
|
|
end = buf.index(b"\0", pos)
|
|
out[key] = buf[pos:end].decode("utf-8", "replace")
|
|
pos = end + 1
|
|
elif t in (0x02, 0x03, 0x04, 0x06):
|
|
pos += 4
|
|
elif t in (0x07, 0x0A):
|
|
pos += 8
|
|
else:
|
|
raise ValueError("type %#x" % t)
|
|
|
|
|
|
def linux_games(file):
|
|
"""{appid: runtime} for the games with a Linux build in the client's appinfo cache."""
|
|
try:
|
|
buf = open(file, "rb").read()
|
|
except OSError:
|
|
return {}
|
|
magic = struct.unpack_from("<I", buf, 0)[0]
|
|
strings, pos = None, 8
|
|
if magic == 0x07564429:
|
|
table = struct.unpack_from("<q", buf, 8)[0]
|
|
count, p = struct.unpack_from("<I", buf, table)[0], table + 4
|
|
strings = []
|
|
for _ in range(count):
|
|
end = buf.index(b"\0", p)
|
|
strings.append(buf[p:end].decode("utf-8", "replace"))
|
|
p = end + 1
|
|
pos = 16
|
|
elif magic != 0x07564428:
|
|
return {}
|
|
games = {}
|
|
while True:
|
|
try:
|
|
appid, size = struct.unpack_from("<II", buf, pos)
|
|
except struct.error:
|
|
break
|
|
if appid == 0:
|
|
break
|
|
KNOWN.add(str(appid))
|
|
try:
|
|
info = read_kv(buf, pos + 8 + 60, strings)[0].get("appinfo", {})
|
|
except (ValueError, IndexError, struct.error):
|
|
info = {}
|
|
pos += 8 + size
|
|
common = info.get("common", {})
|
|
if str(common.get("type", "")).lower() != "game" or "linux" not in str(common.get("oslist", "")):
|
|
continue
|
|
runtime = "scout"
|
|
for m in (info.get("config", {}).get("app_mappings") or {}).values():
|
|
if isinstance(m, dict) and m.get("platform") == "linux":
|
|
tool = str(m.get("tool", "")).lower()
|
|
runtime = "sniper" if "sniper" in tool else "soldier" if "soldier" in tool else runtime
|
|
games[str(appid)] = runtime
|
|
WINDOWS_DEPOTS[str(appid)] = {
|
|
d for d, v in (info.get("depots") or {}).items()
|
|
if isinstance(v, dict) and "windows" in str((v.get("config") or {}).get("oslist", ""))
|
|
and "linux" not in str((v.get("config") or {}).get("oslist", ""))
|
|
}
|
|
return games
|
|
|
|
|
|
def manifest(app):
|
|
"""The app's appmanifest text from the first of the client's libraries (internal storage, the
|
|
card) holding one, or None."""
|
|
for library in steamapps.split(":"):
|
|
try:
|
|
return open(os.path.join(library, "appmanifest_%s.acf" % app), encoding="utf-8", errors="replace").read()
|
|
except OSError:
|
|
pass
|
|
return None
|
|
|
|
|
|
def installed_apps():
|
|
found = set()
|
|
for library in steamapps.split(":"):
|
|
try:
|
|
found |= {m.group(1) for m in map(re.compile(r"appmanifest_(\d+)\.acf$").match, os.listdir(library)) if m}
|
|
except OSError:
|
|
pass
|
|
return found
|
|
|
|
|
|
def new_linux_build(app):
|
|
"""For a title the appinfo cache does not know yet (bought while the client runs): installed as
|
|
itself, not as a Windows build through a compatibility tool, and not one of Valve's runtimes or
|
|
Protons, which the client installs as apps too."""
|
|
text = manifest(app) or ""
|
|
if re.search(r'"platform_override_source"\s*"windows"', text, re.I):
|
|
return False
|
|
folder = re.search(r'"installdir"\s*"([^"]*)"', text)
|
|
return not re.match(r"steam ?linux ?runtime|proton|steamworks shared", folder.group(1) if folder else "", re.I)
|
|
|
|
|
|
def windows_installed(app):
|
|
"""Whether the installed build of `app` is its Windows one (a Windows depot among those installed),
|
|
in any of the client's libraries (internal storage, the card)."""
|
|
text = manifest(app)
|
|
if text is None:
|
|
return False
|
|
found = block(text, "InstalledDepots")
|
|
if not found:
|
|
return False
|
|
installed = set(re.findall(r'"(\d+)"\s*\{', text[found[1]:found[2]]))
|
|
return bool(installed & WINDOWS_DEPOTS.get(app, set()))
|
|
|
|
|
|
def block(text, key):
|
|
"""(start of the key, index after its opening brace, index of its closing brace) or None."""
|
|
m = re.search(r'"%s"\s*\{' % re.escape(key), text)
|
|
if not m:
|
|
return None
|
|
depth, k = 1, m.end()
|
|
while depth:
|
|
c = text[k]
|
|
depth += c == "{"
|
|
depth -= c == "}"
|
|
k += 1
|
|
return m.start(), m.end(), k - 1
|
|
|
|
|
|
games = linux_games(appinfo)
|
|
for app in extra:
|
|
games.setdefault(app, "scout")
|
|
s = open(path, encoding="utf-8", errors="surrogateescape").read()
|
|
if not block(s, "CompatToolMapping"):
|
|
st = block(s, "Steam")
|
|
if not st:
|
|
sys.exit("no Steam section")
|
|
s = s[:st[1]] + '\n\t\t\t\t"CompatToolMapping"\n\t\t\t\t{\n\t\t\t\t}' + s[st[1]:]
|
|
|
|
|
|
def entries(inner):
|
|
"""{app: its entry's span in `inner`, as block() gives it}, read once for the whole mapping."""
|
|
spans, pos = {}, 0
|
|
for m in re.finditer(r'"(\d+)"\s*\{', inner):
|
|
if m.start() < pos:
|
|
continue
|
|
depth, k = 1, m.end()
|
|
while depth and k < len(inner):
|
|
depth += {"{": 1, "}": -1}.get(inner[k], 0)
|
|
k += 1
|
|
spans.setdefault(m.group(1), (m.start(), m.end(), k - 1))
|
|
pos = k
|
|
return spans
|
|
|
|
|
|
def decide(app, inner, old):
|
|
"""(the tool `app` goes to, or None when its entry stays; its entry's span `old` in `inner`; the
|
|
tool that entry names, None without one)."""
|
|
on_windows = windows_installed(app)
|
|
name = None
|
|
if old:
|
|
name = re.search(r'"name"\s*"([^"]*)"', inner[old[1]:old[2]])
|
|
name = name.group(1) if name else ""
|
|
automatic = name in ("", "droiddeck-direct", "droiddeck-proton-arm64", "droiddeck-fex") or name.startswith("proton_")
|
|
if not automatic and app not in extra:
|
|
return None, old, name
|
|
if on_windows and (name == proton or not proton):
|
|
return None, old, name
|
|
elif on_windows and not proton:
|
|
return None, old, name
|
|
return (proton if on_windows else "droiddeck-direct"), old, name
|
|
|
|
|
|
if mode == "live":
|
|
_, open_, close = block(s, "CompatToolMapping")
|
|
inner = s[open_:close]
|
|
spans = entries(inner)
|
|
new = []
|
|
for app in sorted(installed_apps(), key=int):
|
|
if app not in games and (app in KNOWN or not new_linux_build(app)):
|
|
continue
|
|
tool, _, name = decide(app, inner, spans.get(app))
|
|
if tool == "droiddeck-direct" and name != tool:
|
|
new.append(app)
|
|
if new:
|
|
open(pending, "a").write("".join("%s\n" % a for a in new))
|
|
print("droiddeck-steam-x64: installed while the client runs, for DroidDeck direct at its restart: %s" % " ".join(new))
|
|
sys.exit(0)
|
|
_, open_, close = block(s, "CompatToolMapping")
|
|
inner = s[open_:close]
|
|
spans = entries(inner)
|
|
mapped, windows, added, dropped = [], [], [], []
|
|
for app in sorted(games, key=int):
|
|
tool, old, _ = decide(app, inner, spans.get(app))
|
|
if tool is None:
|
|
continue
|
|
if old:
|
|
dropped.append(old)
|
|
added.append('\n\t\t\t\t\t"%s"\n\t\t\t\t\t{\n\t\t\t\t\t\t"name"\t\t"%s"\n'
|
|
'\t\t\t\t\t\t"config"\t\t""\n\t\t\t\t\t\t"priority"\t\t"250"\n\t\t\t\t\t}' % (app, tool))
|
|
(mapped if tool == "droiddeck-direct" else windows).append(app)
|
|
for old in sorted(dropped, reverse=True):
|
|
inner = inner[:old[0]] + inner[old[2] + 1:]
|
|
s = s[:open_] + "".join(reversed(added)) + inner + s[close:]
|
|
open(path, "w", encoding="utf-8", errors="surrogateescape").write(s)
|
|
json.dump(mapped, open(auto_file, "w"))
|
|
open(sniper_file, "w").write("".join("%s\n" % a for a in mapped if games[a] != "scout"))
|
|
print("droiddeck-steam-x64: %d Linux title(s) on DroidDeck direct (%d on the newer runtime)%s"
|
|
% (len(mapped), sum(games[a] != "scout" for a in mapped),
|
|
"; %d installed as Windows games kept on %s" % (len(windows), proton) if windows else ""))
|
|
PY
|
|
}
|
|
|
|
# Whether every program in the FEX tree at $1 finds its libraries (r4 did not without libxxhash).
|
|
fex_loads() {
|
|
local b out
|
|
for b in FEX FEXServer unsquashfs; do
|
|
out=$(/usr/lib/ld-linux-aarch64.so.1 --list "$1/usr/local/bin/$b" 2>&1) && ! grep -q "not found" <<<"$out" && continue
|
|
echo "== FEX check: $b: $(grep -E "not found|error" <<<"$out" | tr -s '\t ' ' ' | tr '\n' ';')" >&2
|
|
return 1
|
|
done
|
|
}
|
|
|
|
# Installs one FEX build only once its archive matches the sha256 and it loads. The files it replaces are kept
|
|
# until the installed copy loads too, and put back otherwise; the tag is written last.
|
|
fex_install() {
|
|
local tag=$1 sha=$2 urls=$3 dst=/ tmp u f
|
|
tmp=$(mktemp -d)
|
|
for u in $urls; do
|
|
curl -fsSL --retry 2 "$u" -o "$tmp/fex.tzst" && echo "$sha $tmp/fex.tzst" | sha256sum -c --quiet >/dev/null 2>&1 && break
|
|
rm -f "$tmp/fex.tzst"
|
|
done
|
|
if [ ! -s "$tmp/fex.tzst" ]; then
|
|
echo "== FEX $tag: no source gave the archive with sha256 ${sha:0:12}" >&2
|
|
rm -rf "$tmp"
|
|
return 1
|
|
fi
|
|
if ! { mkdir "$tmp/root" && zstd -dc "$tmp/fex.tzst" | tar -C "$tmp/root" -x && fex_loads "$tmp/root"; }; then
|
|
rm -rf "$tmp"
|
|
return 1
|
|
fi
|
|
(cd "$tmp/root" && find . ! -type d) > "$tmp/files"
|
|
mkdir "$tmp/old"
|
|
while IFS= read -r f; do
|
|
f=${f#./}
|
|
if [ -e "$dst$f" ] || [ -L "$dst$f" ]; then
|
|
cp -a --parents "$dst$f" "$tmp/old" || { echo "== FEX $tag: could not keep $dst$f aside" >&2; rm -rf "$tmp"; return 1; }
|
|
fi
|
|
done < "$tmp/files"
|
|
if tar -C "$tmp/root" -c . | tar -C "$dst" -x && fex_loads "$dst" &&
|
|
mkdir -p "${dst}usr/local/share/fex-emu" && echo "$tag" > "${dst}usr/local/share/fex-emu/.droiddeck-tag"; then
|
|
rm -rf "$tmp"
|
|
return 0
|
|
fi
|
|
echo "== FEX $tag: the installed copy did not load or its tag was not written; putting the previous files back" >&2
|
|
while IFS= read -r f; do
|
|
f=${f#./}
|
|
[ -e "$tmp/old/$dst$f" ] || [ -L "$tmp/old/$dst$f" ] || rm -f "$dst$f"
|
|
done < "$tmp/files"
|
|
tar -C "$tmp/old$dst" -c . | tar -C "$dst" -x || echo "== FEX $tag: could not put the previous files back" >&2
|
|
rm -rf "$tmp"
|
|
return 1
|
|
}
|
|
|
|
# The build DroidDeck-Components' fex.json names (the app passes it as BL_FEX_*) comes first, then a working
|
|
# installed one, then FEX_TAG above. Sets FEX_NOW and FEX_FROM.
|
|
x64_fex() {
|
|
local have ok=
|
|
have=$(cat /usr/local/share/fex-emu/.droiddeck-tag 2>/dev/null || true)
|
|
[ -x /usr/local/bin/FEX ] && fex_loads / && ok=1
|
|
if [ -n "${BL_FEX_TAG:-}" ]; then
|
|
if [ -n "$ok" ] && [ "$have" = "$BL_FEX_TAG" ]; then FEX_NOW=$have FEX_FROM=catalog; return 0; fi
|
|
step "downloading FEX ($BL_FEX_TAG)"
|
|
if fex_install "$BL_FEX_TAG" "${BL_FEX_SHA256:-}" "${BL_FEX_URLS:-}"; then FEX_NOW=$BL_FEX_TAG FEX_FROM=catalog; return 0; fi
|
|
if [ -n "$ok" ]; then FEX_NOW=$have FEX_FROM="kept; $BL_FEX_TAG did not install"; return 0; fi
|
|
fi
|
|
if [ -n "$ok" ] && [ "$have" = "$FEX_TAG" ]; then FEX_NOW=$have FEX_FROM=built-in; return 0; fi
|
|
step "downloading FEX ($FEX_TAG)"
|
|
if fex_install "$FEX_TAG" "$FEX_SHA256" "$FEX_URL"; then FEX_NOW=$FEX_TAG FEX_FROM=built-in; return 0; fi
|
|
if [ -n "$ok" ]; then FEX_NOW=$have FEX_FROM="kept; $FEX_TAG did not install"; return 0; fi
|
|
return 1
|
|
}
|
|
|
|
# A resumable download that reports every tenth of its size as a step.
|
|
x64_fetch() {
|
|
local url=$1 out=$2 label=$3 total pid rc=0 last=-1 pct
|
|
total=$(curl -fsSIL "$url" 2>/dev/null | tr -d '\r' | awk 'tolower($1) == "content-length:" { v = $2 } END { print v + 0 }')
|
|
curl -fL -sS -C - "$url" -o "$out" &
|
|
pid=$!
|
|
while kill -0 "$pid" 2>/dev/null; do
|
|
sleep 3
|
|
[ "$total" -gt 0 ] || continue
|
|
pct=$(( $(stat -c %s "$out" 2>/dev/null || echo 0) * 10 / total * 10 ))
|
|
if [ "$pct" -gt "$last" ]; then last=$pct; step "$label ($pct%)"; fi
|
|
done
|
|
wait "$pid" || rc=$?
|
|
return "$rc"
|
|
}
|
|
|
|
x64_prepare() {
|
|
x64_fex || { step "FEX could not be installed; see $LOG"; exit 1; }
|
|
step "FEX ready ($FEX_NOW, $FEX_FROM)"
|
|
# The client's opt-in to its SteamRT3 build; without it, it re-executes through steam.sh, whose checks fail under proot.
|
|
mkdir -p "$STEAM_X64" && : > "$STEAM_X64/.steam-enable-steamrt64-client"
|
|
|
|
if [ ! -f "$ROOTFS/.droiddeck-complete" ]; then
|
|
# Resumes a part-done download; a finished one answers 416, which is not a failure here.
|
|
x64_fetch "$ROOTFS_URL" "$X64_HOME/rootfs.sqsh" "downloading FEX's Ubuntu 24.04 x86 rootfs" || {
|
|
rc=$?
|
|
[ "$rc" = 22 ] && [ -s "$X64_HOME/rootfs.sqsh" ] || { step "rootfs download failed (curl $rc)"; exit 1; }
|
|
}
|
|
if ! echo "$ROOTFS_SHA256 $X64_HOME/rootfs.sqsh" | sha256sum -c --quiet >/dev/null 2>&1; then
|
|
rm -f "$X64_HOME/rootfs.sqsh"; step "rootfs download did not match its checksum; try again"; exit 1
|
|
fi
|
|
step "unpacking the rootfs"
|
|
rm -rf "$ROOTFS"
|
|
/usr/local/bin/unsquashfs -no-xattrs -no-progress -ignore-errors -d "$ROOTFS" "$X64_HOME/rootfs.sqsh" >>"$LOG" 2>&1 || true
|
|
[ -x "$ROOTFS/usr/bin/bash" ] || { step "rootfs unpack failed (no usr/bin/bash); see $LOG"; exit 1; }
|
|
rm -f "$X64_HOME/rootfs.sqsh"
|
|
touch "$ROOTFS/.droiddeck-complete"
|
|
fi
|
|
echo "== x86-64 rootfs: $(sed -n 's|.*/download/\([^/]*\)/.*|\1|p' <<<"$ROOTFS_URL") (sha256 ${ROOTFS_SHA256:0:12})" >&2
|
|
# FEX falls back to the guest's own /etc/ld.so.preload (arm64 libraries) when the rootfs has none. The x86
|
|
# session shim provides System V IPC, which Android kernels lack and the client's tier0 needs to start.
|
|
: > "$ROOTFS/etc/ld.so.preload"
|
|
for lib in libblsession libfakeinput; do
|
|
have=0
|
|
# 32-bit libfakeinput crashes SDL2 games (a NULL udev attribute reaches strdup), so only the x86_64 copy
|
|
# is preloaded, by full path: with $LIB, FEX falls through to the session's own i386 copy.
|
|
arches="x86_64 i386"; [ "$lib" = libfakeinput ] && arches=x86_64
|
|
rm -f "$ROOTFS/usr/local/lib/i386-linux-gnu/libfakeinput.so"
|
|
for arch in $arches; do
|
|
[ -f "/usr/local/lib/droiddeck-fex/$arch/$lib.so" ] || continue
|
|
mkdir -p "$ROOTFS/usr/local/lib/$arch-linux-gnu"
|
|
cp -f "/usr/local/lib/droiddeck-fex/$arch/$lib.so" "$ROOTFS/usr/local/lib/$arch-linux-gnu/$lib.so"
|
|
have=1
|
|
done
|
|
if [ "$have" = 1 ] && [ "$lib" = libfakeinput ]; then
|
|
echo "/usr/local/lib/x86_64-linux-gnu/$lib.so" >> "$ROOTFS/etc/ld.so.preload"
|
|
elif [ "$have" = 1 ]; then echo "/usr/local/\$LIB/$lib.so" >> "$ROOTFS/etc/ld.so.preload"
|
|
else step "warning: no x86 build of $lib (/usr/local/lib/droiddeck-fex/x86_64/$lib.so)"; fi
|
|
done
|
|
rm -f "$ROOTFS/usr/local/lib/libblsession-x86_64.so" "$ROOTFS/usr/local/lib/libfakeinput-x86_64.so"
|
|
unconfirmed=$STEAM_X64/package/droiddeck-unconfirmed
|
|
if [ -d "${unconfirmed%/*}" ] && ! grep -qx tracked "$unconfirmed" 2>/dev/null; then echo tracked > "$unconfirmed"; fi
|
|
x64_repair=
|
|
if [ "${BL_X64_REPAIR:-0}" = 1 ]; then
|
|
x64_repair=requested
|
|
elif [ -f "$unconfirmed" ] && ! grep -qx repaired "$unconfirmed" && [ "$(grep -cx start "$unconfirmed")" -ge 2 ]; then
|
|
x64_repair="the client was started $(grep -cx start "$unconfirmed") times without showing anything"
|
|
fi
|
|
if [ -n "$x64_repair" ]; then
|
|
step "repairing the x86-64 Steam client ($x64_repair)"
|
|
rm -f "$STEAM_X64/package/droiddeck-installed" "$STEAM_X64/.crash" "$STEAM_X64/steam.pid" \
|
|
"$STEAM_X64"/package/steam_client_*.installed
|
|
fi
|
|
if [ ! -x "$STEAM_X64/steamrt64/steam" ] || [ ! -f "$STEAM_X64/package/droiddeck-installed" ]; then
|
|
step "downloading the x86-64 Steam client ($MANIFEST)"
|
|
work=$(mktemp -d)
|
|
curl -fsSL "$CDN/$MANIFEST" -o "$work/manifest"
|
|
version=$(awk -F'"' '$2 == "version" { print $4; exit }' "$work/manifest")
|
|
awk -F'"' '
|
|
/^\t"/ && NF >= 3 && $4 == "" { block = $2 }
|
|
$2 == "file" { file[block] = $4 }
|
|
$2 == "sha2" { sha[block] = $4 }
|
|
END { for (b in file) if (b ~ /_all$/ || b ~ /_steamrt64$/) print b, file[b], sha[b] }
|
|
' "$work/manifest" | sort > "$work/parts"
|
|
[ -s "$work/parts" ] || { step "no client components in $MANIFEST"; exit 1; }
|
|
mkdir -p "$STEAM_X64/package"
|
|
total=$(grep -c . "$work/parts")
|
|
i=0
|
|
while read -r block file sum; do
|
|
i=$((i + 1))
|
|
step "client: $block ($i/$total)"
|
|
curl -fsSL "$CDN/$file" -o "$work/$file"
|
|
echo "$sum $work/$file" | sha256sum -c --quiet
|
|
unzip -qo "$work/$file" -d "$STEAM_X64"
|
|
rm -f "$work/$file"
|
|
done < "$work/parts"
|
|
cp -f "$work/manifest" "$STEAM_X64/package/$MANIFEST.manifest"
|
|
rm -rf "$work"
|
|
echo "$X64_CHANNEL" > "$STEAM_X64/package/beta"
|
|
echo "$version" > "$STEAM_X64/package/droiddeck-installed"
|
|
chmod +x "$STEAM_X64/steam.sh" "$STEAM_X64/steamrt64/steam" "$STEAM_X64/ubuntu12_32/steam" 2>/dev/null || true
|
|
fi
|
|
[ -n "$x64_repair" ] && printf 'tracked\nrepaired\n' > "$unconfirmed"
|
|
x64_sync_client
|
|
scout=$STEAM_X64/ubuntu12_32
|
|
if [ -f "$scout/steam-runtime.tar.xz" ] &&
|
|
{ [ ! -x "$scout/steam-runtime/run.sh" ] ||
|
|
! cmp -s "$scout/steam-runtime.tar.xz.checksum" "$scout/steam-runtime/checksum"; }; then
|
|
step "unpacking Valve's scout runtime for native Linux games"
|
|
rm -rf "$scout/steam-runtime.new"
|
|
mkdir -p "$scout/steam-runtime.new"
|
|
if tar -xJf "$scout/steam-runtime.tar.xz" -C "$scout/steam-runtime.new" && [ -x "$scout/steam-runtime.new/steam-runtime/run.sh" ]; then
|
|
rm -rf "$scout/steam-runtime"
|
|
mv "$scout/steam-runtime.new/steam-runtime" "$scout/steam-runtime"
|
|
cp -f "$scout/steam-runtime.tar.xz.checksum" "$scout/steam-runtime/checksum" 2>/dev/null || true
|
|
else
|
|
step "could not unpack the scout runtime; native Linux games will not start"
|
|
fi
|
|
rm -rf "$scout/steam-runtime.new"
|
|
fi
|
|
[ -L "$STEAM_X64/steamapps" ] && rm -f "$STEAM_X64/steamapps"
|
|
mkdir -p "$STEAM_X64/steamapps"
|
|
# FEX looks in the rootfs first: an empty dev/dri there hides the session's KGSL node, which x86 programs spin on.
|
|
mkdir -p "$ROOTFS/dev/dri"
|
|
mkdir -p "$X64_HOME/.steam"
|
|
ln -sfn "$STEAM_X64" "$X64_HOME/.steam/root"
|
|
ln -sfn "$STEAM_X64" "$X64_HOME/.steam/steam"
|
|
ln -sfn "$STEAM_X64/ubuntu12_32" "$X64_HOME/.steam/bin32"
|
|
ln -sfn "$STEAM_X64/ubuntu12_64" "$X64_HOME/.steam/bin64"
|
|
ln -sfn "$STEAM_X64/linux32" "$X64_HOME/.steam/sdk32"
|
|
ln -sfn "$STEAM_X64/linux64" "$X64_HOME/.steam/sdk64"
|
|
# The client's bwrap probe (steam-runtime-check-requirements) needs user namespaces, which no Android app has.
|
|
srt_real=$STEAM_X64/steamrt64/pv-runtime/steam-runtime-steamrt
|
|
srt_shim=$X64_HOME/steamrt-shim
|
|
if [ -d "$srt_real" ]; then
|
|
rm -rf "$srt_shim"
|
|
mkdir -p "$srt_shim/bin"
|
|
for e in "$srt_real"/* "$srt_real"/.[!.]*; do
|
|
[ -e "$e" ] || continue
|
|
[ "$(basename "$e")" = bin ] || ln -s "$e" "$srt_shim/$(basename "$e")"
|
|
done
|
|
for e in "$srt_real"/bin/*; do ln -s "$e" "$srt_shim/bin/$(basename "$e")"; done
|
|
rm -f "$srt_shim/bin/steam-runtime-check-requirements"
|
|
printf '#!/bin/sh
|
|
exit 0
|
|
' > "$srt_shim/bin/steam-runtime-check-requirements"
|
|
chmod 755 "$srt_shim/bin/steam-runtime-check-requirements"
|
|
rm -f "$srt_shim/bin/steam-runtime-launch-client"
|
|
cat > "$srt_shim/bin/steam-runtime-launch-client" <<'LAUNCH'
|
|
#!/bin/sh
|
|
while [ $# -gt 0 ]; do
|
|
case $1 in
|
|
--) shift; break ;;
|
|
--directory=*) cd "${1#--directory=}" || exit 127 ;;
|
|
--env=*) export "${1#--env=}" ;;
|
|
--unset-env=*) unset "${1#--unset-env=}" ;;
|
|
esac
|
|
shift
|
|
done
|
|
[ $# -gt 0 ] || exit 0
|
|
exec "$@"
|
|
LAUNCH
|
|
chmod 755 "$srt_shim/bin/steam-runtime-launch-client"
|
|
fi
|
|
# Valve's platform libraries ship without soname links (pressure-vessel makes them); ldconfig adds them here.
|
|
srt_libs=$X64_HOME/steamrt-libs
|
|
rm -rf "$srt_libs"
|
|
mkdir -p "$srt_libs"
|
|
for d in "$STEAM_X64"/steamrt64/pv-runtime/steam-runtime-steamrt/steamrt3c_platform_*/files/lib/x86_64-linux-gnu \
|
|
"$STEAM_X64"/steamrt64/pv-runtime/steam-runtime-steamrt/steamrt3c_platform_*/files/usr/lib/x86_64-linux-gnu; do
|
|
[ -d "$d" ] || continue
|
|
for f in "$d"/*.so*; do [ -e "$srt_libs/$(basename "$f")" ] || ln -s "$f" "$srt_libs/"; done
|
|
done
|
|
FEX_ROOTFS=$ROOTFS /usr/local/bin/FEX "$ROOTFS/usr/sbin/ldconfig.real" -n "$srt_libs" >>"$LOG" 2>&1 || step "ldconfig on $srt_libs failed"
|
|
# The rootfs's HarfBuzz needs a newer FreeType than some games bundle (Counter-Strike 2): use Valve's runtime one.
|
|
sniper_compat=$X64_HOME/sniper-compat
|
|
rm -rf "$sniper_compat"
|
|
mkdir -p "$sniper_compat"
|
|
hb=$(ls "$srt_libs"/libharfbuzz.so.0.* 2>/dev/null | head -n 1)
|
|
if [ -n "$hb" ]; then ln -s "$hb" "$sniper_compat/libharfbuzz.so.0"; else step "warning: no HarfBuzz in Valve's runtime for the newer-runtime titles"; fi
|
|
# LD_LIBRARY_PATH beats the system folders whatever its order: Valve's older glibc must not shadow the rootfs's.
|
|
for f in "$srt_libs"/*; do
|
|
n=$(basename "$f")
|
|
if [ -e "$ROOTFS/usr/lib/x86_64-linux-gnu/$n" ] || [ -e "$ROOTFS/lib/x86_64-linux-gnu/$n" ]; then rm -f "$f"; fi
|
|
done
|
|
tool=$STEAM_X64/compatibilitytools.d/droiddeck-direct
|
|
mkdir -p "$tool"
|
|
rm -f "$tool/droiddeck-proton-wrap" "$tool/toolmanifest.vdf.droiddeck-orig"
|
|
cat > "$tool/compatibilitytool.vdf" <<'VDF'
|
|
"compatibilitytools"
|
|
{
|
|
"compat_tools"
|
|
{
|
|
"droiddeck-direct"
|
|
{
|
|
"install_path" "."
|
|
"display_name" "DroidDeck direct (no container)"
|
|
"from_oslist" "linux"
|
|
"to_oslist" "linux"
|
|
}
|
|
}
|
|
}
|
|
VDF
|
|
cat > "$tool/toolmanifest.vdf" <<'VDF'
|
|
"manifest"
|
|
{
|
|
"version" "2"
|
|
"commandline" "/run %verb%"
|
|
}
|
|
VDF
|
|
printf '%s\n' "$REAL_HOME/.droiddeck-vac-diagnostics" > "$tool/vac-marker"
|
|
cat > "$tool/run" <<'RUN'
|
|
#!/bin/sh
|
|
verb=$1; shift
|
|
rt=$HOME/.local/share/Steam/ubuntu12_32/steam-runtime.old
|
|
[ -x "$rt/run.sh" ] || rt=$HOME/.local/share/Steam/ubuntu12_32/steam-runtime
|
|
# -condebug only while VAC diagnostics are on (the marker is in the real home, not this client's).
|
|
marker=$(cat "${0%/*}/vac-marker" 2>/dev/null)
|
|
case "$*" in *hl2.sh*|*hl2_linux*|*srcds*) [ -n "$marker" ] && [ -f "$marker" ] && set -- "$@" -condebug ;; esac
|
|
# game-gpu.env is rewritten whenever the launcher runs; game-gpu.local is the user's and is read after it.
|
|
gpu=$HOME/game-gpu.env
|
|
if [ -f "$gpu" ] && [ "${BL_X64_GAME_SOFTWARE:-0}" != 1 ]; then
|
|
. "$gpu"
|
|
[ -f "$HOME/game-gpu.local" ] && . "$HOME/game-gpu.local"
|
|
else
|
|
export mesa_glthread=false
|
|
fi
|
|
case $verb in
|
|
run|waitforexitandrun)
|
|
# Titles Valve gives a newer runtime (sniper, soldier) need newer libraries than scout's: the rootfs's.
|
|
if grep -qx "${STEAM_COMPAT_APP_ID:-${SteamAppId:-none}}" "$HOME/direct-sniper" 2>/dev/null; then
|
|
[ -e "$HOME/sniper-compat/libharfbuzz.so.0" ] &&
|
|
export LD_PRELOAD="$HOME/sniper-compat/libharfbuzz.so.0${LD_PRELOAD:+:$LD_PRELOAD}"
|
|
case $1 in
|
|
*.sh)
|
|
if grep -q '^[[:space:]]*\. /etc/os-release' "$1" 2>/dev/null; then
|
|
script=$1; shift
|
|
exec bash -c "$(sed 's|^\([[:space:]]*\)\. /etc/os-release|\1VERSION_CODENAME=sniper|' "$script")" "$script" "$@"
|
|
fi ;;
|
|
esac
|
|
exec "$@"
|
|
fi
|
|
exec "$rt/run.sh" "$@" ;;
|
|
*) exec "$@" ;;
|
|
esac
|
|
RUN
|
|
chmod 755 "$tool/run"
|
|
if [ ! -f "$STEAM_X64/config/config.vdf" ] && ! pgrep -f 'steamrt64/steam( |$)' >/dev/null 2>&1; then
|
|
mkdir -p "$STEAM_X64/config"
|
|
printf '"InstallConfigStore"\n{\n\t"Software"\n\t{\n\t\t"Valve"\n\t\t{\n\t\t\t"Steam"\n\t\t\t{\n\t\t\t\t"CompatToolMapping"\n\t\t\t\t{\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n}\n' \
|
|
> "$STEAM_X64/config/config.vdf"
|
|
fi
|
|
x64_map_direct
|
|
# Each wrapper execs droiddeck-x64-arm-proton through an arm64 binary, which FEX hands straight to the CPU.
|
|
arm_tools=$ARM_STEAM/compatibilitytools.d
|
|
mkdir -p "$X64_HOME/arm64"
|
|
cp -f /usr/bin/env "$X64_HOME/arm64/env"
|
|
for w in "$STEAM_X64"/compatibilitytools.d/*/.droiddeck-arm64-proton; do
|
|
[ -e "$w" ] || continue
|
|
d=${w%/.droiddeck-arm64-proton}
|
|
[ -d "$arm_tools/${d##*/}" ] && [ "${d##*/}" != droiddeck-fex ] || rm -rf "$d"
|
|
done
|
|
for src in "$arm_tools"/*/; do
|
|
src=${src%/}; name=${src##*/}
|
|
[ -f "$src/compatibilitytool.vdf" ] && [ -f "$src/toolmanifest.vdf" ] || continue
|
|
# A droiddeck-fex wrapper made the arm64 client install Valve's FEX when this client probed its tools after logon.
|
|
case $name in droiddeck-direct|droiddeck-fex) continue ;; esac
|
|
dst=$STEAM_X64/compatibilitytools.d/$name
|
|
mkdir -p "$dst"
|
|
rm -f "$dst/droiddeck-proton-wrap" "$dst/toolmanifest.vdf.droiddeck-orig"
|
|
: > "$dst/.droiddeck-arm64-proton"
|
|
python3 - "$src/compatibilitytool.vdf" "$dst/compatibilitytool.vdf" <<'PY' || { rm -rf "$dst"; continue; }
|
|
import re, sys
|
|
s = open(sys.argv[1], encoding="utf-8", errors="replace").read()
|
|
m = re.search(r'"compat_tools"\s*\{\s*"([^"]+)"', s)
|
|
if not m:
|
|
sys.exit(1)
|
|
# The x86-64 client ignores a tool named arm64 or aarch64 ("for a different target platform linux arm64").
|
|
key = re.sub(r"arm64|aarch64", "a64", m.group(1))
|
|
d = re.search(r'"display_name"\s*"([^"]*)"', s)
|
|
name = d.group(1) if d else key
|
|
open(sys.argv[2], "w").write(
|
|
'"compatibilitytools"\n{\n "compat_tools"\n {\n "%s"\n {\n "install_path" "."\n'
|
|
' "display_name" "%s"\n "from_oslist" "windows"\n "to_oslist" "linux"\n }\n }\n}\n'
|
|
% (key, name))
|
|
PY
|
|
cat > "$dst/toolmanifest.vdf" <<'VDF'
|
|
"manifest"
|
|
{
|
|
"version" "2"
|
|
"commandline" "/run %verb%"
|
|
}
|
|
VDF
|
|
printf '#!/bin/sh\n# The arm64 client'"'"'s %s, run natively (droiddeck-x64-arm-proton).\nexec "%s" /usr/local/bin/droiddeck-x64-arm-proton "%s" "$@"\n' \
|
|
"$name" "$X64_HOME/arm64/env" "$name" > "$dst/run"
|
|
chmod 755 "$dst/run"
|
|
done
|
|
x64_sync_login
|
|
# Each client keeps its own libraries; written only while no x86 client runs, as it rewrites these on exit.
|
|
if ! pgrep -f 'steamrt64/steam( |$)' >/dev/null 2>&1; then
|
|
listing_ok=0
|
|
if python3 - "$STEAM_X64" "${BL_X64_STEAM_LIBRARIES:-}" "$STEAM_X64/config/libraryfolders.vdf" "$STEAM_X64/steamapps/libraryfolders.vdf" <<'PY'; then
|
|
import json, os, re, sys
|
|
keep = {os.path.realpath(sys.argv[1])}
|
|
# Without the session's list nothing is known about the card: leave the folders as they are.
|
|
if not sys.argv[2]:
|
|
sys.exit(3)
|
|
try:
|
|
keep |= {os.path.realpath(str(e["path"])) for e in json.load(open(sys.argv[2], encoding="utf-8"))}
|
|
except (OSError, ValueError, KeyError, TypeError):
|
|
sys.exit(3)
|
|
for path in sys.argv[3:]:
|
|
if not os.path.isfile(path):
|
|
continue
|
|
s = open(path, encoding="utf-8", errors="surrogateescape").read()
|
|
out, removed, i = [], [], 0
|
|
for m in re.finditer(r'^\t"(\d+)"\s*\n\t\{', s, re.M):
|
|
if m.start() < i:
|
|
continue
|
|
depth, k = 1, m.end()
|
|
while depth and k < len(s):
|
|
depth += s[k] == "{"
|
|
depth -= s[k] == "}"
|
|
k += 1
|
|
block = s[m.start():k]
|
|
p = re.search(r'"path"\s*"([^"]*)"', block)
|
|
if p and os.path.realpath(p.group(1)) not in keep:
|
|
out.append(s[i:m.start()])
|
|
i = k + (1 if s[k:k + 1] == "\n" else 0)
|
|
removed.append(p.group(1))
|
|
if not removed:
|
|
continue
|
|
out.append(s[i:])
|
|
open(path, "w", encoding="utf-8", errors="surrogateescape").write("".join(out))
|
|
print("droiddeck-steam-x64: no longer shared with the arm64 client: %s" % ", ".join(removed))
|
|
PY
|
|
listing_ok=1
|
|
elif [ $? = 3 ]; then
|
|
step "no library list from the session: the x86-64 client's library folders are left as they are"
|
|
else
|
|
step "could not check the x86-64 client's library folders"
|
|
fi
|
|
if [ "$listing_ok" = 1 ]; then
|
|
BL_STEAM_LIBRARIES=$BL_X64_STEAM_LIBRARIES droiddeck-steam-library "$STEAM_X64" ||
|
|
step "could not add the card to the x86-64 client's library folders"
|
|
fi
|
|
fi
|
|
# default-tool is the default this script set: titles still on it move along; a user's choice is kept.
|
|
default=$(x64_default_dir)
|
|
if [ -f "$default/compatibilitytool.vdf" ] && [ -f "$STEAM_X64/config/config.vdf" ] &&
|
|
! pgrep -f 'steamrt64/steam( |$)' >/dev/null 2>&1; then
|
|
python3 - "$STEAM_X64/config/config.vdf" "$default/compatibilitytool.vdf" "$X64_HOME/default-tool" <<'PY' || step "could not make ARM64 Proton the default"
|
|
import os, re, sys
|
|
path, vdf, record = sys.argv[1:4]
|
|
tool = re.search(r'"compat_tools"\s*\{\s*"([^"]+)"', open(vdf).read()).group(1)
|
|
s = open(path, encoding="utf-8", errors="surrogateescape").read()
|
|
m = re.search(r'"CompatToolMapping"\s*\{', s)
|
|
if not m:
|
|
sys.exit(0)
|
|
depth, k = 1, m.end()
|
|
while depth:
|
|
depth += s[k] == "{"
|
|
depth -= s[k] == "}"
|
|
k += 1
|
|
block = s[m.end():k]
|
|
try:
|
|
previous = open(record).read().strip() or None
|
|
except OSError:
|
|
previous = None
|
|
z = re.search(r'^\s*"0"\s*\{([^{}]*)\}', block, re.M)
|
|
if z:
|
|
name = re.search(r'"name"\s*"([^"]*)"', z.group(1))
|
|
name = name.group(1) if name else ""
|
|
set_here = re.search(r'"priority"\s*"75"', z.group(1)) is not None
|
|
if previous is None and set_here and name.endswith("-a64"):
|
|
previous = name
|
|
if "arm64" not in z.group(1) and name != previous:
|
|
sys.exit(0)
|
|
if name == tool and previous == tool:
|
|
sys.exit(0)
|
|
block = block[:z.start()] + block[z.end():]
|
|
moved = 0
|
|
if previous and previous != tool:
|
|
block, moved = re.subn(r'("name"\s*")%s(")' % re.escape(previous), lambda x: x.group(1) + tool + x.group(2), block)
|
|
entry = ('\n\t\t\t\t\t"0"\n\t\t\t\t\t{\n\t\t\t\t\t\t"name"\t\t"%s"\n' % tool +
|
|
'\t\t\t\t\t\t"config"\t\t""\n\t\t\t\t\t\t"priority"\t\t"75"\n\t\t\t\t\t}')
|
|
s = s[:m.end()] + entry + block + s[k:]
|
|
open(path, "w", encoding="utf-8", errors="surrogateescape").write(s)
|
|
open(record, "w").write(tool + "\n")
|
|
if moved:
|
|
print("droiddeck-steam-x64: default %s -> %s, with the %d titles on it" % (previous, tool, moved))
|
|
PY
|
|
fi
|
|
if [ -d "$ARM_STEAM/config/uioverrides" ] && [ ! -e "$STEAM_X64/config/uioverrides" ]; then
|
|
ln -s "$ARM_STEAM/config/uioverrides" "$STEAM_X64/config/uioverrides"
|
|
fi
|
|
if [ -f "$ARM_STEAM/.cef-enable-remote-debugging" ]; then
|
|
: > "$STEAM_X64/.cef-enable-remote-debugging"
|
|
else
|
|
rm -f "$STEAM_X64/.cef-enable-remote-debugging"
|
|
fi
|
|
if [ -f "$ARM_STEAM/config/config.vdf" ] && [ -f "$STEAM_X64/config/config.vdf" ] &&
|
|
! pgrep -f 'steamrt64/steam( |$)' >/dev/null 2>&1; then
|
|
python3 - "$ARM_STEAM/config/config.vdf" "$STEAM_X64/config/config.vdf" <<'PY' || step "could not copy the startup movie choice"
|
|
import re, sys
|
|
movie = re.search(r'\n([ \t]*)"StartupMovie"\s*\{[^{}]*\}', open(sys.argv[1], encoding="utf-8", errors="replace").read())
|
|
if not movie:
|
|
sys.exit(0)
|
|
path = sys.argv[2]
|
|
s = open(path, encoding="utf-8", errors="surrogateescape").read()
|
|
old = re.search(r'\n[ \t]*"StartupMovie"\s*\{[^{}]*\}', s)
|
|
if old:
|
|
if old.group(0).split(None, 1)[1] == movie.group(0).split(None, 1)[1]:
|
|
sys.exit(0)
|
|
s = s[:old.start()] + s[old.end():]
|
|
steam = re.search(r'"Valve"\s*\{\s*"Steam"\s*\{', s)
|
|
if not steam:
|
|
sys.exit(0)
|
|
s = s[:steam.end()] + movie.group(0) + s[steam.end():]
|
|
open(path, "w", encoding="utf-8", errors="surrogateescape").write(s)
|
|
PY
|
|
fi
|
|
# FEX takes its rootfs from FEXServer, and one started without FEX_ROOTFS serves none: stop it while no x86 client runs.
|
|
if ! pgrep -f 'steamrt64/steam( |$)' >/dev/null 2>&1; then
|
|
FEX_ROOTFS=$ROOTFS /usr/local/bin/FEXServer -k >/dev/null 2>&1 || true
|
|
fi
|
|
}
|
|
|
|
x64_gpu() {
|
|
[ "${BL_X64_SOFTWARE:-0}" != 1 ] && [ -d /usr/local/share/fex-emu/GuestThunks ] && [ -d /usr/local/lib/fex-emu/HostThunks ]
|
|
}
|
|
|
|
x64_webhelper_gpu() {
|
|
x64_gpu && [ "${BL_X64_CLIENT_SOFTWARE:-0}" != 1 ] && [ "${BL_X64_CEF_GPU:-1}" != 0 ]
|
|
}
|
|
|
|
x64_env() {
|
|
# droiddeck-x64-arm-proton restores this arm64 environment before Proton runs.
|
|
export -p | grep -v -E '^declare -x (PWD|OLDPWD|SHLVL|_)=' > "$X64_HOME/arm-session.env.new" || true
|
|
mv -f "$X64_HOME/arm-session.env.new" "$X64_HOME/arm-session.env"
|
|
unset LD_LIBRARY_PATH LD_PRELOAD STEAM_RUNTIME STEAM_RUNTIME_PREFER_HOST_LIBRARIES
|
|
gpu_vars="GALLIUM_DRIVER MESA_LOADER_DRIVER_OVERRIDE VK_ICD_FILENAMES VK_DRIVER_FILES LIBGL_KOPPER_DRI2 ZINK_DEBUG ZINK_DESCRIPTORS TU_DEBUG MESA_NO_ERROR mesa_glthread"
|
|
rm -f "$X64_HOME/game-gpu.env"
|
|
if x64_gpu; then
|
|
printf '{"ThunksDB": {"GL": 1, "Vulkan": 1}}\n' > "$X64_HOME/thunks.json"
|
|
{
|
|
echo "export FEX_THUNKCONFIG='$X64_HOME/thunks.json'"
|
|
echo "unset LIBGL_ALWAYS_SOFTWARE LIBGL_DRI3_DISABLE GALLIUM_DRIVER"
|
|
for v in $gpu_vars; do
|
|
eval "val=\${$v-}"; [ -n "$val" ] && printf "export %s='%s'\n" "$v" "$val"
|
|
done
|
|
} > "$X64_HOME/game-gpu.env"
|
|
fi
|
|
if x64_gpu && [ "${BL_X64_CLIENT_SOFTWARE:-0}" != 1 ]; then
|
|
export FEX_THUNKCONFIG=$X64_HOME/thunks.json
|
|
unset LIBGL_ALWAYS_SOFTWARE LIBGL_DRI3_DISABLE
|
|
else
|
|
unset FEX_THUNKCONFIG $gpu_vars
|
|
export LIBGL_ALWAYS_SOFTWARE=1 GALLIUM_DRIVER=llvmpipe
|
|
# Over DRI3 the X server hands out the GPU node, and Mesa's software path loops on KMS dumb buffers on it.
|
|
export LIBGL_DRI3_DISABLE=1
|
|
fi
|
|
[ "${BL_X64_FP_OFF:-0}" = 1 ] && export PROOT_FP_OFF=1
|
|
export FEX_TSOENABLED=${FEX_TSOENABLED:-1} FEX_VECTORTSOENABLED=${FEX_VECTORTSOENABLED:-0} \
|
|
FEX_MEMCPYSETTSOENABLED=${FEX_MEMCPYSETTSOENABLED:-0} FEX_HALFBARRIERTSOENABLED=${FEX_HALFBARRIERTSOENABLED:-0} \
|
|
FEX_X87REDUCEDPRECISION=${FEX_X87REDUCEDPRECISION:-1} FEX_MULTIBLOCK=${FEX_MULTIBLOCK:-1}
|
|
export HOME=$X64_HOME
|
|
export XDG_DATA_HOME=$X64_HOME/.local/share XDG_CONFIG_HOME=$X64_HOME/.config XDG_CACHE_HOME=$X64_HOME/.cache
|
|
export FEX_ROOTFS=$ROOTFS
|
|
export STEAM_EXTRA_COMPAT_TOOLS_PATHS=
|
|
export STEAM_RUNTIME=1
|
|
[ -d "$X64_HOME/steamrt-shim" ] && export STEAM_RUNTIME_STEAMRT=$X64_HOME/steamrt-shim
|
|
# The client starts commands via steam-runtime-launch-client; Valve's needs a session-bus service, the shim's runs them.
|
|
[ -d "$X64_HOME/steamrt-shim/bin" ] && export PATH=$X64_HOME/steamrt-shim/bin:$PATH
|
|
export LD_LIBRARY_PATH=$STEAM_X64/steamrt64:$STEAM_X64/steamrt64/panorama:$X64_HOME/steamrt-libs
|
|
# After an update the client re-executes itself through pressure-vessel-wrap (bwrap) unless this guard is set.
|
|
export STEAM_STEAMRT_RECURSION_GUARD=1
|
|
# proot is a tracer: tier0 takes it for a debugger and breaks into it with int3 on its first failed assertion.
|
|
export BL_WEBHELPER_HIDE_TRACER=1
|
|
}
|
|
|
|
x64_manifest_version() {
|
|
local chan
|
|
chan=$(cat "$STEAM_X64/package/beta" 2>/dev/null || echo "$X64_CHANNEL")
|
|
awk -F'"' '$2 == "version" { print $4; exit }' "$STEAM_X64/package/steam_client_${chan}_$1.manifest" 2>/dev/null || echo "?"
|
|
}
|
|
|
|
# What x86 GL and Vulkan look like through FEX's thunks, for a session whose menus failed on the GPU.
|
|
x64_gpu_probe() {
|
|
local fex=${BL_FEX:-/usr/local/bin/FEX}
|
|
echo "== x86-64 GPU probe (x86 glxinfo and vulkaninfo through FEX):"
|
|
(
|
|
unset LD_LIBRARY_PATH
|
|
export DISABLE_GAMESCOPE_WSI=1 vk_xwayland_wait_ready=true LIBGL_KOPPER_DISABLE=true
|
|
timeout 30 "$fex" /usr/bin/glxinfo -B 2>&1 | grep -E "OpenGL (renderer|core profile version|version) string|direct rendering|rror" | head -5
|
|
timeout 30 "$fex" /usr/bin/vulkaninfo --summary 2>&1 | grep -E "deviceName|driverName|driverInfo|apiVersion|rror" | head -6
|
|
) | sed 's/^/ /'
|
|
}
|
|
|
|
# Steam's menus come from the web helper; when its GPU process keeps exiting, Chromium gives up on the GPU and
|
|
# the menus never appear. Says so once in the session log, with the probe above.
|
|
x64_gpu_watch() {
|
|
local log=$STEAM_X64/logs/console-linux.txt from n codes
|
|
from=$(( $(wc -l 2>/dev/null < "$log" || echo 0) + 1 ))
|
|
tail -n0 -F --pid=$$ "$log" 2>/dev/null | grep -q -m1 "GPU process isn't usable" || return 0
|
|
n=$(tail -n +"$from" "$log" | grep -c "GPU process exited unexpectedly" || true)
|
|
codes=$(tail -n +"$from" "$log" | grep -oE "GPU process exited unexpectedly: exit_code=[0-9]+" | sed 's/.*=//' |
|
|
sort | uniq -c | awk '{ printf "%s%s x%s", s, $2, $1; s = ", " }')
|
|
echo "== x86-64: Steam's menu renderer gave up on the GPU after $n GPU process exits (exit code ${codes:-?}); the menus stay blank. See steam/console-linux.txt and steam/webhelper_gpu.txt"
|
|
x64_gpu_probe
|
|
}
|
|
|
|
x64_exec() {
|
|
x64_env
|
|
cd "$STEAM_X64"
|
|
# The client checksums its files at start and reinstalls over edited ones, so the session shim (preload/net.c)
|
|
# swaps the web helper at exec. The arm64 helper only comes up against a client of the same build.
|
|
if [ "${BL_X64_X86_WEBHELPER:-0}" != 1 ] && [ -x /usr/local/bin/droiddeck-x64-arm-webhelper ] &&
|
|
[ -x "$ARM_STEAM/steamrtarm64/steamwebhelper" ]; then
|
|
local chan x86_build arm_build
|
|
chan=$(cat "$STEAM_X64/package/beta" 2>/dev/null || echo "$X64_CHANNEL")
|
|
x86_build=$(awk -F'"' '$2 == "version" { print $4; exit }' "$STEAM_X64/package/steam_client_${chan}_steamrt64.manifest" 2>/dev/null || true)
|
|
arm_build=$(awk -F'"' '$2 == "version" { print $4; exit }' "$ARM_STEAM/package/steam_client_${chan}_linuxarm64.manifest" 2>/dev/null || true)
|
|
if [ -n "$x86_build" ] && [ "$x86_build" = "$arm_build" ]; then
|
|
export BL_X64_ARM_WEBHELPER=/usr/local/bin/droiddeck-x64-arm-webhelper
|
|
else
|
|
echo "== x86-64 client build ${x86_build:-?}, arm64 web helper's ${arm_build:-?}: keeping the x86 web helper" >&2
|
|
fi
|
|
fi
|
|
if [ -z "${BL_X64_ARM_WEBHELPER:-}" ] && x64_webhelper_gpu; then
|
|
# Not --in-process-gpu (the preload's default): a GPU crash there takes the whole helper down.
|
|
export BL_WEBHELPER_ARGS="--ignore-gpu-blocklist --use-gl=angle --use-angle=gl --ozone-platform=x11"
|
|
[ -x /usr/local/bin/droiddeck-x64-webhelper ] && export BL_X64_ARM_WEBHELPER=/usr/local/bin/droiddeck-x64-webhelper
|
|
elif [ -z "${BL_X64_ARM_WEBHELPER:-}" ]; then
|
|
export BL_WEBHELPER_ARGS=stock
|
|
local a args=() soft=0
|
|
for a in "$@"; do
|
|
case $a in
|
|
-cef-force-gpu|-cef-ozone-platform=*|-cef-use-gl=*|-cef-use-angle=*) soft=1 ;;
|
|
*) args+=("$a") ;;
|
|
esac
|
|
done
|
|
[ "$soft" = 1 ] && set -- "${args[@]}" -cef-disable-gpu
|
|
fi
|
|
mkdir -p "$STEAM_X64/logs"
|
|
touch "$STEAM_X64/logs/bootstrap_log.txt"
|
|
( tail -n0 -F --pid=$$ "$STEAM_X64/logs/bootstrap_log.txt" 2>/dev/null |
|
|
grep --line-buffered -oE 'Downloading update \([0-9,]+ of [0-9,]+ KB\)' | sed -u 's/,//g' >&2 ) &
|
|
echo "== x86-64 client: steamrt64 $(x64_manifest_version steamrt64) (the client may update itself)" >&2
|
|
x64_webhelper_gpu && { x64_gpu_watch >&2 & }
|
|
exec "${BL_FEX:-/usr/local/bin/FEX}" "$STEAM_X64/steamrt64/steam" "$@"
|
|
}
|
|
|
|
# Steam renews its token every few days and refuses old copies: copy the newest every start, never while a client runs.
|
|
x64_sync_login() {
|
|
pgrep -f 'steamrt64/steam( |$)' >/dev/null 2>&1 && return 0
|
|
pgrep -f 'steamrtarm64/steam( |$)' >/dev/null 2>&1 && return 0
|
|
python3 - "$ARM_STEAM" "$STEAM_X64" "$REAL_HOME/.steam/registry.vdf" "$X64_HOME/.steam/registry.vdf" <<'PY' || step "could not share the sign-in between the clients"
|
|
import os, re, shutil, sys
|
|
arm, x64, arm_reg, x64_reg = sys.argv[1:5]
|
|
FILES = ("config/loginusers.vdf", "local.vdf")
|
|
|
|
|
|
def read(path):
|
|
try:
|
|
return open(path, encoding="utf-8", errors="surrogateescape").read()
|
|
except OSError:
|
|
return None
|
|
|
|
|
|
def write(path, text):
|
|
open(path, "w", encoding="utf-8", errors="surrogateescape").write(text)
|
|
|
|
|
|
def block(text, name):
|
|
m = re.search(r'"%s"\s*\{' % name, text)
|
|
if not m:
|
|
return None
|
|
depth, k = 1, m.end()
|
|
while depth and k < len(text):
|
|
depth += text[k] == "{"
|
|
depth -= text[k] == "}"
|
|
k += 1
|
|
return m, k
|
|
|
|
|
|
def accounts(root):
|
|
text = read(os.path.join(root, "config/config.vdf")) or ""
|
|
found = block(text, "Accounts")
|
|
if not found:
|
|
return {}
|
|
return dict(re.findall(r'"([^"]+)"\s*\{\s*"SteamID"\s*"(\d+)"', text[found[0].end():found[1]]))
|
|
|
|
|
|
def add_accounts(root, wanted):
|
|
path = os.path.join(root, "config/config.vdf")
|
|
text = read(path)
|
|
if text is None:
|
|
return
|
|
have = accounts(root)
|
|
missing = {name: sid for name, sid in wanted.items() if name not in have}
|
|
if not missing:
|
|
return
|
|
entries = "".join('\n\t\t\t\t\t"%s"\n\t\t\t\t\t{\n\t\t\t\t\t\t"SteamID"\t\t"%s"\n\t\t\t\t\t}' % item for item in missing.items())
|
|
found = block(text, "Accounts")
|
|
if found:
|
|
text = text[:found[0].end()] + entries + text[found[0].end():]
|
|
else:
|
|
steam = re.search(r'"Valve"\s*\{\s*"Steam"\s*\{', text)
|
|
if not steam:
|
|
return
|
|
text = text[:steam.end()] + '\n\t\t\t\t"Accounts"\n\t\t\t\t{' + entries + '\n\t\t\t\t}' + text[steam.end():]
|
|
write(path, text)
|
|
|
|
|
|
def set_keys(src_reg, dst_reg, force):
|
|
st, dt = read(src_reg), read(dst_reg)
|
|
if st is None or dt is None:
|
|
return
|
|
for key in ("AutoLoginUser", "RememberPassword"):
|
|
v = re.search(r'"%s"\s*"([^"]*)"' % key, st)
|
|
if not v:
|
|
continue
|
|
if re.search(r'"%s"\s*"' % key, dt):
|
|
if force:
|
|
dt = re.sub(r'("%s"\s*")[^"]*(")' % key, lambda m: m.group(1) + v.group(1) + m.group(2), dt, count=1)
|
|
continue
|
|
hkcu = re.search(r'"HKCU"\s*\{\s*"Software"\s*\{\s*"Valve"\s*\{\s*"Steam"\s*\{\n', dt)
|
|
if hkcu:
|
|
dt = dt[:hkcu.end()] + '\t\t\t\t\t"%s"\t\t"%s"\n' % (key, v.group(1)) + dt[hkcu.end():]
|
|
write(dst_reg, dt)
|
|
|
|
|
|
def stamp(root):
|
|
if not all(os.path.isfile(os.path.join(root, f)) for f in FILES):
|
|
return None
|
|
# A client that refused its token leaves an empty ConnectCache: newest, but copying it signs the other out.
|
|
text = open(os.path.join(root, "local.vdf"), encoding="utf-8", errors="surrogateescape").read()
|
|
if not re.search(r'"ConnectCache"\s*\{\s*"[^"]+"\s*"[^"]+"', text):
|
|
return None
|
|
return os.path.getmtime(os.path.join(root, "local.vdf"))
|
|
|
|
|
|
a, x = stamp(arm), stamp(x64)
|
|
if a is not None or x is not None:
|
|
if x is None or (a is not None and a > x):
|
|
src, dst, sreg, dreg, who = arm, x64, arm_reg, x64_reg, "arm64"
|
|
else:
|
|
src, dst, sreg, dreg, who = x64, arm, x64_reg, arm_reg, "x86-64"
|
|
copy = a is None or x is None or abs(a - x) >= 1
|
|
if copy:
|
|
for f in FILES:
|
|
os.makedirs(os.path.dirname(os.path.join(dst, f)), exist_ok=True)
|
|
# copy2 keeps the time stamp, so both match until one client signs in again.
|
|
shutil.copy2(os.path.join(src, f), os.path.join(dst, f))
|
|
if os.path.isfile(sreg) and not os.path.isfile(dreg):
|
|
os.makedirs(os.path.dirname(dreg), exist_ok=True)
|
|
shutil.copy2(sreg, dreg)
|
|
set_keys(sreg, dreg, copy)
|
|
set_keys(dreg, sreg, False)
|
|
add_accounts(dst, accounts(src))
|
|
add_accounts(src, accounts(dst))
|
|
if copy:
|
|
print("droiddeck-steam-x64: sign-in shared from the %s client (the newer one)" % who)
|
|
PY
|
|
}
|
|
|
|
case "${1:-}" in
|
|
--sync-login) x64_sync_login; exit 0 ;;
|
|
--prepare) x64_prepare; exit 0 ;;
|
|
--exec) shift; x64_exec "$@" ;;
|
|
--gpu) x64_gpu; exit $? ;;
|
|
--webhelper-gpu) x64_webhelper_gpu; exit $? ;;
|
|
--default-tool) x64_default_tool; exit 0 ;;
|
|
--map-direct) shift; x64_map_direct "$@"; exit 0 ;;
|
|
esac
|
|
|
|
if pgrep -f 'steamrtarm64/steam( |$)' >/dev/null 2>&1; then
|
|
step "shutting down the arm64 client first"
|
|
"$ARM_STEAM/steamrtarm64/steam" -shutdown >/dev/null 2>&1 || true
|
|
for _ in $(seq 1 30); do pgrep -f 'steamrtarm64/steam( |$)' >/dev/null 2>&1 || break; sleep 1; done
|
|
fi
|
|
x64_prepare
|
|
step "FEX, rootfs and client ready"
|
|
if [ -n "${BL_FEXSERVER_LOG:-}" ]; then
|
|
FEX_ROOTFS=$ROOTFS "$(dirname "${BL_FEX:-/usr/local/bin/FEX}")/FEXServer" -f -p 600 >"$BL_FEXSERVER_LOG" 2>&1 &
|
|
sleep 1
|
|
fi
|
|
# The client's connection status comes from NetworkManager on the system bus; a desktop has no system bus.
|
|
x64_bus= x64_nm= x64_pin=
|
|
x64_cleanup() {
|
|
[ -n "$x64_pin" ] && kill "$x64_pin" 2>/dev/null
|
|
[ -n "$x64_nm" ] && kill "$x64_nm" 2>/dev/null
|
|
[ -n "$x64_bus" ] && kill "$x64_bus" 2>/dev/null
|
|
return 0
|
|
}
|
|
trap x64_cleanup EXIT
|
|
if ! pgrep -f 'dbus-daemon --config-file=/usr/local/share/droiddeck/system-bus.conf' >/dev/null 2>&1 \
|
|
&& 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>
|
|
<type>system</type>
|
|
<listen>unix:path=/run/dbus/system_bus_socket</listen>
|
|
<auth>EXTERNAL</auth>
|
|
<policy context="default">
|
|
<allow user="*"/>
|
|
<allow own="*"/>
|
|
<allow send_destination="*"/>
|
|
<allow receive_sender="*"/>
|
|
</policy>
|
|
</busconfig>
|
|
BUSCONF
|
|
rm -f /run/dbus/system_bus_socket
|
|
dbus-daemon --config-file=/usr/local/share/droiddeck/system-bus.conf --nofork --nopidfile &
|
|
x64_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
|
|
droiddeck-netmanager &
|
|
x64_nm=$!
|
|
step "network: system bus up, NetworkManager stand-in running"
|
|
else
|
|
step "network: the system bus did not come up; the client will show no connection"
|
|
fi
|
|
fi
|
|
# Left by a killed client: .crash opens the update UI on its spinner; stale Singleton* locks can blank the UI.
|
|
if ! pgrep -f 'steamrt64/steam( |$)' >/dev/null 2>&1; then
|
|
for f in "$STEAM_X64/.crash" "$STEAM_X64/steam.pid" "$STEAM_X64/config/htmlcache/SingletonLock" \
|
|
"$STEAM_X64/config/htmlcache/SingletonCookie" "$STEAM_X64/config/htmlcache/SingletonSocket"; do
|
|
{ [ -e "$f" ] || [ -L "$f" ]; } && rm -f "$f"
|
|
done
|
|
fi
|
|
if [ -n "${BL_CLIENT_CPUS:-}" ] && command -v taskset >/dev/null 2>&1; then
|
|
(
|
|
while sleep 5; do
|
|
for pid in $(ps -A -o PID,ARGS | awk '($2 ~ /^(.*\/)?FEX(Interpreter)?$/) && ($3 ~ /steamrt64\/steam$/ || $3 ~ /steamwebhelper$/) {print $1} $2 ~ /steamrtarm64\/steamwebhelper$/ {print $1}'); do
|
|
taskset -a -p -c "$BL_CLIENT_CPUS" "$pid" >/dev/null 2>&1
|
|
done
|
|
done
|
|
) &
|
|
x64_pin=$!
|
|
fi
|
|
for attempt in 1 2 3 4 5; do
|
|
# The branch on disk must match -clientbeta before every start, or the client loops on rc=42.
|
|
echo "$X64_CHANNEL" > "$STEAM_X64/package/beta"
|
|
step "starting the x86-64 SteamRT3 client under FEX (attempt $attempt): $*"
|
|
rc=0
|
|
if [ "${BL_X64_X86_WEBHELPER:-0}" != 1 ] || x64_webhelper_gpu; then cef=(-cef-force-gpu -cef-ozone-platform=x11 -cef-use-gl=angle -cef-use-angle=vulkan); else cef=(-cef-disable-gpu); fi
|
|
( x64_exec -clientbeta "$X64_CHANNEL" -no-cef-sandbox "${cef[@]}" "$@" ) >>"$LOG" 2>&1 || rc=$?
|
|
step "client exited rc=$rc"
|
|
[ "$rc" = 42 ] || break
|
|
done |