diff --git a/tools/linuxfs/overlay/usr/local/bin/droiddeck-session b/tools/linuxfs/overlay/usr/local/bin/droiddeck-session index 98f105365f..9d9c6d3313 100755 --- a/tools/linuxfs/overlay/usr/local/bin/droiddeck-session +++ b/tools/linuxfs/overlay/usr/local/bin/droiddeck-session @@ -97,7 +97,7 @@ collect_steam_logs() { cp "$fex_state/status.json" "$fex_state/config/Config.json" "$BL_DEBUG_DIR/droiddeck-fex/" 2>/dev/null fi } -trap 'collect_steam_logs 2>/dev/null || true' TERM INT HUP +trap 'bl_stopping=1; collect_steam_logs 2>/dev/null || true' TERM INT HUP 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) bl_icd_lib=$(printf '%s' "$bl_icd_lib" | sed 's|\\/|/|g') @@ -114,9 +114,48 @@ if [ -n "${BL_VK_DRIVER:-}" ]; then fi unset bl_icd_lib fi +bl_now_ms() { + if [ -n "${EPOCHREALTIME:-}" ]; then + local t=${EPOCHREALTIME/[.,]/} + echo $((10#$t / 1000)) + else + date +%s%3N + fi +} +vkbridge_wait_socket() { + local sock=$1 limit=${2:-10000} start now waited + [ -n "$sock" ] || return 1 + if [ -S "$sock" ]; then + echo "== vkbridge: server socket ready (waited 0 ms)" + return 0 + fi + start=$(bl_now_ms) + while :; do + now=$(bl_now_ms) + waited=$((now - start)) + if [ -S "$sock" ]; then + echo "== vkbridge: server socket ready (waited $waited ms; the server listens after its startup probe)" + return 0 + fi + if [ -n "${bl_stopping:-}" ]; then + echo "== vkbridge: no server socket after $waited ms; the session is stopping" + return 1 + fi + if [ "$waited" -ge "$limit" ]; then + echo "== vkbridge: no server socket after $waited ms (gave up at $limit ms)" + return 1 + fi + sleep 0.05 + done +} if [ "${BL_VKBRIDGE:-0}" = 1 ]; then bl_vkb_icd=/usr/local/share/vkbridge/droidbridge_icd.json - if [ -r "$bl_vkb_icd" ] && [ -r /usr/local/lib/vkbridge/libvulkan_droidbridge.so ] && [ -S "${VKBRIDGE_SOCKET:-}" ]; then + [ -z "${BL_INSIDE:-}" ] && vkbridge_wait_socket "${VKBRIDGE_SOCKET:-}" "${BL_VKBRIDGE_WAIT_MS:-10000}" + bl_vkb_missing= + [ -r "$bl_vkb_icd" ] || bl_vkb_missing="$bl_vkb_missing icd" + [ -r /usr/local/lib/vkbridge/libvulkan_droidbridge.so ] || bl_vkb_missing="$bl_vkb_missing library" + [ -S "${VKBRIDGE_SOCKET:-}" ] || bl_vkb_missing="$bl_vkb_missing socket" + if [ -z "$bl_vkb_missing" ]; then export VK_DRIVER_FILES=$bl_vkb_icd VK_ICD_FILENAMES=$bl_vkb_icd export VKBRIDGE_SOCKET VKBRIDGE_CLIENT_LOG if [ -r /root/.vkbridge-env ]; then @@ -136,9 +175,9 @@ if [ "${BL_VKBRIDGE:-0}" = 1 ]; then fi echo "== vulkan driver: Mali bridge ($bl_vkb_icd, server at $VKBRIDGE_SOCKET)" else - echo "== vulkan driver: Mali bridge requested but NOT usable (icd $bl_vkb_icd, socket ${VKBRIDGE_SOCKET:-unset}); this GPU will show a black screen" + echo "== vulkan driver: Mali bridge requested but NOT usable (icd $bl_vkb_icd, socket ${VKBRIDGE_SOCKET:-unset}; missing:$bl_vkb_missing); this GPU will show a black screen" fi - unset bl_vkb_icd + unset bl_vkb_icd bl_vkb_missing fi export GAMESCOPE_FORCE_VULKAN_REALTIME=${BL_GAMESCOPE_REALTIME:-0} diff --git a/tools/tests/test_session_vkbridge_wait.py b/tools/tests/test_session_vkbridge_wait.py new file mode 100644 index 0000000000..bbd4fdb264 --- /dev/null +++ b/tools/tests/test_session_vkbridge_wait.py @@ -0,0 +1,127 @@ +import os +import re +import shutil +import socket +import subprocess +import tempfile +import threading +import time +import unittest +from pathlib import Path + +SESSION = Path(__file__).resolve().parents[1] / "linuxfs/overlay/usr/local/bin/droiddeck-session" + + +def wait_functions(): + text = SESSION.read_text() + found = [] + for name in ("bl_now_ms", "vkbridge_wait_socket"): + match = re.search(r"^%s\(\) \{\n.*?^\}\n" % name, text, re.M | re.S) + if match: + found.append(match.group(0)) + return found + + +class VkBridgeSocketWaitTest(unittest.TestCase): + def setUp(self): + self.root = Path(tempfile.mkdtemp()) + self.addCleanup(shutil.rmtree, self.root, True) + self.sock = self.root / "vkbridge" / "server.sock" + self.sock.parent.mkdir() + self.listeners = [] + self.addCleanup(lambda: [s.close() for s in self.listeners]) + + def listen(self): + listener = socket.socket(socket.AF_UNIX) + listener.bind(str(self.sock)) + listener.listen(1) + self.listeners.append(listener) + + def listen_after(self, seconds): + timer = threading.Timer(seconds, self.listen) + timer.start() + self.addCleanup(timer.cancel) + + def run_wait(self, limit_ms, prelude=""): + functions = wait_functions() + self.assertEqual(2, len(functions), "droiddeck-session lacks bl_now_ms() or vkbridge_wait_socket()") + script = "set -u\n" + "".join(functions) + prelude + script += 'if vkbridge_wait_socket "$1" "$2"; then echo USABLE; else echo FALLBACK; fi\n' + started = time.monotonic() + out = subprocess.run(["bash", "-c", script, "session", str(self.sock), str(limit_ms)], + capture_output=True, text=True, timeout=30, check=True).stdout + return out, time.monotonic() - started + + def waited_ms(self, out): + match = re.search(r"waited (\d+) ms|after (\d+) ms", out) + self.assertIsNotNone(match, out) + return int(match.group(1) or match.group(2)) + + def test_a_socket_already_listening_is_used_at_once(self): + self.listen() + out, elapsed = self.run_wait(10000) + self.assertTrue(out.endswith("USABLE\n"), out) + self.assertIn("== vkbridge: server socket ready (waited 0 ms)", out) + self.assertLess(elapsed, 2) + + def test_a_server_still_probing_is_waited_for(self): + self.listen_after(0.4) + out, elapsed = self.run_wait(10000) + self.assertTrue(out.endswith("USABLE\n"), out) + self.assertIn("== vkbridge: server socket ready (waited ", out) + waited = self.waited_ms(out) + self.assertGreaterEqual(waited, 300, out) + self.assertLess(waited, 5000, out) + self.assertLess(elapsed, 6) + + def test_no_server_falls_back_after_the_limit(self): + out, elapsed = self.run_wait(300) + self.assertTrue(out.endswith("FALLBACK\n"), out) + self.assertIn("== vkbridge: no server socket after ", out) + self.assertIn("(gave up at 300 ms)", out) + self.assertGreaterEqual(self.waited_ms(out), 300) + self.assertLess(elapsed, 5) + + def test_a_plain_file_is_not_a_socket(self): + self.sock.write_text("stale") + out, _ = self.run_wait(200) + self.assertTrue(out.endswith("FALLBACK\n"), out) + + def test_a_stopping_session_does_not_wait(self): + out, elapsed = self.run_wait(10000, prelude="bl_stopping=1\n") + self.assertTrue(out.endswith("FALLBACK\n"), out) + self.assertIn("the session is stopping", out) + self.assertLess(elapsed, 2) + + def test_no_socket_path_is_a_fallback_without_waiting(self): + functions = "".join(wait_functions()) + out = subprocess.run(["bash", "-c", "set -u\n" + functions + + 'if vkbridge_wait_socket "" 10000; then echo USABLE; else echo FALLBACK; fi\n'], + capture_output=True, text=True, timeout=10, check=True).stdout + self.assertEqual("FALLBACK\n", out) + + +class VkBridgeSessionCheckTest(unittest.TestCase): + + def setUp(self): + self.text = SESSION.read_text() + match = re.search(r'^if \[ "\$\{BL_VKBRIDGE:-0\}" = 1 \]; then\n.*?^fi\n', self.text, re.M | re.S) + self.assertIsNotNone(match) + self.block = match.group(0) + + def test_the_first_pass_waits_before_the_usability_check(self): + wait = self.block.index("vkbridge_wait_socket") + check = self.block.index('[ -S "${VKBRIDGE_SOCKET:-}" ]') + self.assertLess(wait, check) + self.assertIn('[ -z "${BL_INSIDE:-}" ] && vkbridge_wait_socket', self.block) + + def test_the_fallback_message_names_what_is_missing(self): + self.assertIn("Mali bridge requested but NOT usable", self.block) + self.assertIn("missing:$bl_vkb_missing", self.block) + + def test_a_stop_ends_the_wait(self): + self.assertRegex(self.text, r"trap '[^']*bl_stopping=1[^']*' TERM INT HUP") + + +if __name__ == "__main__": + unittest.main()