#!/bin/bash # The Linux runtime's session. Bannerlator 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 a Linux program (AppImage, script or ELF) # bannerlator-session steam [steam-url] the native Steam client # bannerlator-session lxqt the LXQt/labwc desktop (SteamDeck'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} mode=${1:-desktop} shift || true # One line per milestone, greppable as "== STEP", so a first run reads as a narrative rather than # something to be reconstructed from Steam's own chatter. The app shows these while it waits. step() { echo "== STEP $(date -u +%H:%M:%S) $*"; } if [ -n "${BL_LOG:-}" ] && [ -z "${BL_INSIDE:-}" ]; then mkdir -p "$(dirname "$BL_LOG")" 2>/dev/null # The client alone writes megabytes an hour; one earlier log is kept, not every session's. if [ "$(stat -c %s "$BL_LOG" 2>/dev/null || echo 0)" -gt 8388608 ]; then mv -f "$BL_LOG" "$BL_LOG.1" fi exec >>"$BL_LOG" 2>&1 echo "== bannerlator-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)" echo "== rootfs: $(cat /.version 2>/dev/null || echo unversioned)" fi # Until the runtime is stable, Steam's own logs are copied beside the session log at exit so a # failed launch can be handed over as one folder. collect_steam_logs() { [ -n "${BL_DEBUG_DIR:-}" ] || return 0 local steam_root=${XDG_DATA_HOME:-$HOME/.local/share}/Steam mkdir -p "$BL_DEBUG_DIR" 2>/dev/null || return 0 [ -d "$steam_root/logs" ] && cp -r "$steam_root/logs" "$BL_DEBUG_DIR/steam-logs" 2>/dev/null [ -f "$HOME/.steam/steam/logs/steamwebhelper.log" ] && cp "$HOME/.steam/steam/logs/steamwebhelper.log" "$BL_DEBUG_DIR/" 2>/dev/null [ -f "$steam_root/steam.pid" ] && cp "$steam_root/steam.pid" "$BL_DEBUG_DIR/" 2>/dev/null echo "== steam logs copied to $BL_DEBUG_DIR" } # The driver everything in this session draws with: gamescope's compositing, the client's UI # (OpenGL through Zink), every game Proton launches, and in desktop mode every program on it. # BL_VK_DRIVER names an imported driver's ICD manifest on the Android side, which is bound into the # session at its own path; unset means the runtime keeps the Turnip it was built with. # VK_DRIVER_FILES REPLACES the loader's search, so a manifest whose library is unreadable would # leave the session with no Vulkan at all - check both before setting it, and say so in the log # rather than fail silently half a minute later. if [ -n "${BL_VK_DRIVER:-}" ]; then bl_icd_lib=$(sed -n 's/.*"library_path"[[:space:]]*:[[:space:]]*"\([^"]*\)".*/\1/p' "$BL_VK_DRIVER" 2>/dev/null | head -1) # JSON may escape the separator: org.json writes "\/data\/user\/0\/...". The Vulkan loader # parses that correctly; this check has to as well, or an absolute path looks relative and gets # glued onto the manifest's directory - which is exactly what happened the first time. bl_icd_lib=$(printf '%s' "$bl_icd_lib" | sed 's|\\/|/|g') case $bl_icd_lib in /*) ;; ?*) bl_icd_lib="$(dirname "$BL_VK_DRIVER")/$bl_icd_lib" ;; esac if [ -r "$BL_VK_DRIVER" ] && [ -n "$bl_icd_lib" ] && [ -r "$bl_icd_lib" ]; then export VK_DRIVER_FILES="$BL_VK_DRIVER" # Loaders older than 1.3.207 only know the old name; both are harmless together. export VK_ICD_FILENAMES="$BL_VK_DRIVER" echo "== vulkan driver: imported $bl_icd_lib (via $BL_VK_DRIVER)" else echo "== vulkan driver: IGNORING $BL_VK_DRIVER (manifest or ${bl_icd_lib:-library} unreadable); using the runtime's own" fi unset bl_icd_lib fi export XDG_DATA_HOME=${XDG_DATA_HOME:-$HOME/.local/share} 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 [ -z "${BL_INSIDE:-}" ]; then # The compositor may still be starting, and a socket left by an earlier session is not # a compositor: probe until a connection succeeds. for _ in $(seq 1 100); do wayland-info >/dev/null 2>&1 && break sleep 0.1 done # The desktop (SteamDeck's hosted package) is its own nested compositor, labwc, drawing straight # into the app's: no gamescope in between. if [ "$mode" = lxqt ]; then step "starting the desktop" [ -x /usr/local/bin/steamdeck-desktop ] || { echo "== the desktop package is not installed"; exit 66; } exec /usr/local/bin/steamdeck-desktop fi width=${BL_WIDTH:-1280} height=${BL_HEIGHT:-720} args=(--backend wayland --expose-wayland -f -W "$width" -H "$height" -w "$width" -h "$height") # -r is what gamescope advertises as the refresh rate, and what a game reads as the display's. # Left unset it defaults to 60, so a 120 Hz panel offers only 60 Hz in game settings. The FPS # limiter wins when it is on (it is a deliberate cap); otherwise use the panel's own rate. if [ "${BL_FPS:-0}" -gt 0 ]; then args+=(-r "$BL_FPS") elif [ "${BL_REFRESH:-0}" -gt 0 ]; then args+=(-r "$BL_REFRESH") fi [ "$mode" = steam ] && args+=(-e) export BL_INSIDE=1 exec gamescope "${args[@]}" -- "$0" "$mode" "$@" fi # gamescope manages X windows: toolkits go through Xwayland, not gamescope's own Wayland socket. export GDK_BACKEND=x11 QT_QPA_PLATFORM=xcb SDL_VIDEODRIVER=x11 # gamescope's reaper waits for every process left under it before the compositor comes down. A # process a game left behind - a Wine service blocked on a server that is already gone - is # reparented there when the client exits, and the screen stays black on it for good. Nothing of # the session outlives the program it was started for. reap_orphans() { local round p stat pid left for round in 1 2 3 4 5; do left= for p in /proc/[0-9]*; do pid=${p#/proc/} [ "$pid" = "$$" ] && continue stat=$(cat "$p/stat" 2>/dev/null) || continue stat=${stat##*) } set -- $stat [ "${2:-}" = "$PPID" ] && left="$left $pid" done [ -n "$left" ] || return 0 echo "== leaving behind:$left" kill -9 $left 2>/dev/null sleep 0.2 done } case $mode in desktop) exec pcmanfm ;; run) target=${1:?program path} shift case ${target,,} in *.appimage) export APPIMAGE_EXTRACT_AND_RUN=1 chmod +x "$target" 2>/dev/null exec "$target" "$@" ;; *.sh) exec bash "$target" "$@" ;; *) chmod +x "$target" 2>/dev/null cd "$(dirname "$target")" && exec "$target" "$@" ;; esac ;; steam) step "checking the Steam client (first run downloads it, ~1-2 min with nothing on screen)" bannerlator-steam-install || exit $? step "Steam client ready" steam_root=$XDG_DATA_HOME/Steam # Register the card library (bound at /mnt/bannerlator-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. # 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 _bl_left=$HOME/.bl-proton-extra.left : > "$_bl_left" 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 step "installed Proton '$_bl_extra'" else step "Proton '$_bl_extra' failed; will retry next session" echo "$_bl_extra" >> "$_bl_left" fi done < "$HOME/.bl-proton-extra" mv -f "$_bl_left" "$HOME/.bl-proton-extra" fi # steam:// URLs left in ~/.bl-steam-urls are handed to the client on its command line. The app # writes one when the user asks for a Proton that is one of Valve's own depots rather than a # tarball: those are not files anywhere, the client fetches them like any other app. One per # line, and the file is cleared once they have been passed on - the client either acts on a URL # or it does not, and repeating it every session would re-ask forever. if [ -s "$HOME/.bl-steam-urls" ]; then while read -r _bl_url || [ -n "$_bl_url" ]; do case ${_bl_url# } in steam://*) ;; *) continue ;; esac step "asking the client for $_bl_url" set -- "$@" "$_bl_url" done < "$HOME/.bl-steam-urls" rm -f "$HOME/.bl-steam-urls" fi # Cores for the client itself. Steam pins its own interface renderer to a subset - on the # device it took 5 of 8, leaving out both little cores and the fastest one - which is a # reasonable thing to do while a game is running and the wrong thing when the client is all # there is. BL_CLIENT_CPUS overrides it. Re-applied on a beat because steamwebhelper spawns # children continuously and each one inherits Steam's choice, not ours. if [ -n "${BL_CLIENT_CPUS:-}" ]; then step "client cores: $BL_CLIENT_CPUS" ( for _ in $(seq 1 720); do for _p in $(pgrep -f 'steamwebhelper|steamrtarm64/steam|gamescope' 2>/dev/null); do taskset -cp "$BL_CLIENT_CPUS" "$_p" >/dev/null 2>&1 || true done sleep 5 done ) & fi step "registering the app's game library with Steam" bannerlator-steam-library "$steam_root" || true step "setting up the ARM64 Proton compatibility tool" bannerlator-steam-compat "$steam_root" || true # 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 # 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 fi # The tool is registered before the client starts and finds the depot at launch time, so # nothing here waits for a download. What can still change under a running client is which # titles are installed: a title installed this session gets the client's own per-app Proton # choice, which it cannot start. Refresh the per-app entries every so often; the registrar is # idempotent, so a repeat costs nothing. # The seeder has the same problem and a worse consequence. It marks the shared redistributables # as already run in each prefix that exists, and a game's prefix is not created until the # client launches it - so a title played for the first time this session was never covered, and # its install scripts run for real. That is exactly the hang the seeder exists to prevent: Need # for Speed Payback sat on "Running install script" with vcredist_x86.exe blocked in pipe_read, # holding both ends of a pipe nobody would write to, while the client waited for it to exit. # Seeding again on the same beat covers a prefix the moment it appears. # The seeder runs on a shorter beat than the registrar because it is racing something. The # client creates a prefix when it launches a title and runs that title's install scripts # moments later, so the seeder has only that gap to mark the redistributables as already run. # It stamps each prefix it has covered and skips it thereafter, so the extra passes cost # almost nothing. ( beat=0 for _ in $(seq 1 720); do sleep 5 bannerlator-seed-redists "$steam_root" >/dev/null 2>&1 || true beat=$((beat + 1)) if [ "$((beat % 3))" -eq 0 ]; then bannerlator-steam-compat "$steam_root" >/dev/null 2>&1 || true fi done ) & # Debug aid while the runtime is being brought up: an app id dropped in ~/.bl-autolaunch is # handed to the client as a rungameid URL, so a launch can be reproduced without touching the # screen. Removed once the runtime is stable. if [ -s "$HOME/.bl-autolaunch" ]; then _bl_app=$(cat "$HOME/.bl-autolaunch") # A bare app id runs the game; a full steam:// URL is passed through, which is how a # validate or an install is driven without touching the screen. case $_bl_app in steam://*) _bl_url=$_bl_app ;; *) _bl_url=steam://rungameid/$_bl_app ;; esac echo "== autolaunch $_bl_url" set -- "$@" "$_bl_url" fi 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 # The client exits 42 when it has updated itself and wants a fresh start (steam.sh does this). while :; do step "starting the Steam client" "$steam_root/steamrtarm64/steam" -gamepadui -clientbeta publicbeta \ -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 [ "$rc" -eq 42 ] || break done reap_orphans exit "$rc" ;; *) echo "bannerlator-session: unknown mode '$mode'" >&2 exit 64 ;; esac