mirror of
https://github.com/Droid-Deck/DroidDeck.git
synced 2026-11-18 12:28:40 +00:00
447 lines
17 KiB
Python
Executable File
447 lines
17 KiB
Python
Executable File
#!/usr/bin/env python3
|
|
import argparse
|
|
import hashlib
|
|
import json
|
|
import os
|
|
from pathlib import Path
|
|
import re
|
|
import sys
|
|
import time
|
|
|
|
|
|
PREFIX = "DROIDDECK_PROCESS_TRACE "
|
|
SCHEMA = 1
|
|
DEFAULT_INTERVAL_MS = 5_000
|
|
DEFAULT_DURATION_MS = 86_400_000
|
|
DEFAULT_MAX_RECORDS = 512
|
|
HEARTBEAT_MS = 300_000
|
|
MAX_PROCESSES = 256
|
|
MAX_MAP_BYTES = 8 * 1024 * 1024
|
|
MAX_MAP_LINES = 65_536
|
|
MAX_LIBRARIES = 128
|
|
MAX_CMDLINE_BYTES = 16 * 1024
|
|
MAX_ENUMERATED_PROCESSES = 4_096
|
|
MAX_CHILDREN_BYTES = 64 * 1024
|
|
SAFE_LIBRARY = re.compile(r"[A-Za-z0-9._+-]{1,128}")
|
|
WINDOWS_GRAPHICS_LIBRARIES = {
|
|
"d3d8.dll", "d3d9.dll", "d3d10.dll", "d3d10_1.dll", "d3d10core.dll",
|
|
"d3d11.dll", "d3d12.dll", "dxgi.dll", "vulkan-1.dll",
|
|
}
|
|
KNOWN_GRAPHICS_SONAMES = {
|
|
"libvulkan.so", "libvulkan_freedreno.so", "libvulkan_panfrost.so", "libvulkan_lvp.so",
|
|
"libvulkan_virtio.so", "libvulkan_dzn.so", "libvulkan_broadcom.so",
|
|
"libEGL.so", "libEGL_mesa.so", "libGLESv1_CM.so", "libGLESv2.so", "libGLESv3.so",
|
|
"libGL.so", "libGLX.so", "libGLX_mesa.so", "libgbm.so", "libwayland-client.so",
|
|
"libX11.so", "libX11-xcb.so", "libdrm.so", "libdrm_amdgpu.so", "libdrm_freedreno.so",
|
|
"libdrm_intel.so", "libdrm_nouveau.so", "libdrm_radeon.so", "libxcb.so", "libxcb-dri2.so",
|
|
"libxcb-dri3.so", "libxcb-glx.so", "libxcb-present.so", "libxcb-randr.so", "libxcb-render.so",
|
|
"libxcb-shm.so", "libxcb-sync.so", "libxcb-xfixes.so", "libhybris-vulkan-icd.so",
|
|
"libVkLayer_hybris_compat.so", "libVkLayer_DROIDDECK_placed_memory.so",
|
|
"libVkLayer_KHRONOS_validation.so", "libVkLayer_FROG_gamescope_wsi_aarch64.so",
|
|
"libVkLayer_MESA_device_select.so", "libVkLayer_MESA_overlay.so", "libvkd3d.so",
|
|
"libvkd3d-shader.so", "libvkd3d-utils.so",
|
|
}
|
|
|
|
|
|
def emit(payload, output=sys.stdout):
|
|
output.write(PREFIX + json.dumps(payload, separators=(",", ":"), sort_keys=True) + "\n")
|
|
output.flush()
|
|
|
|
|
|
def process_stat(path):
|
|
text = path.read_text(errors="replace")
|
|
end = text.rfind(") ")
|
|
if end < 0:
|
|
raise ValueError("invalid process stat")
|
|
fields = text[end + 2:].split()
|
|
if len(fields) < 20:
|
|
raise ValueError("short process stat")
|
|
return int(fields[1]), fields[19]
|
|
|
|
|
|
def bounded_bytes(path, limit):
|
|
with path.open("rb") as source:
|
|
return source.read(limit)
|
|
|
|
|
|
def process_role(comm, cmdline):
|
|
probe = (comm + "\0" + cmdline.decode("utf-8", "replace")).lower()
|
|
if "steamwebhelper" in probe:
|
|
return "steam-webhelper"
|
|
if "gamescope" in probe:
|
|
return "gamescope"
|
|
if "xwayland" in probe:
|
|
return "xwayland"
|
|
if "mangoapp" in probe:
|
|
return "mangoapp"
|
|
if "pressure-vessel" in probe or "steam-runtime" in probe:
|
|
return "steam-runtime"
|
|
if "steamrtarm64/steam" in probe or "steamrt64/steam" in probe or comm.lower() == "steam":
|
|
return "steam-client"
|
|
if "fexinterpreter" in probe or comm.lower() == "fex":
|
|
return "fex"
|
|
if "wineserver" in probe:
|
|
return "wineserver"
|
|
if any(name in probe for name in ("wine64", "wine-preloader", "/wine ")):
|
|
return "wine"
|
|
if "pipewire" in probe or "pulseaudio" in probe:
|
|
return "audio-server"
|
|
if "dbus-daemon" in probe:
|
|
return "dbus"
|
|
if "droiddeck-session" in probe:
|
|
return "session"
|
|
return "game-or-helper"
|
|
|
|
|
|
def is_graphics_library(name):
|
|
lower = name.lower()
|
|
return (
|
|
lower in WINDOWS_GRAPHICS_LIBRARIES or
|
|
lower.startswith(("libvulkan", "libvklayer", "vulkan.", "libegl", "libgles", "libglx",
|
|
"libgl.so", "libgbm", "libdrm", "libwayland", "libxcb", "libx11")) or
|
|
"vkd3d" in lower or "dxvk" in lower or "zink" in lower or "mangohud" in lower
|
|
)
|
|
|
|
|
|
def origin_class(path):
|
|
lower = path.lower()
|
|
if lower.startswith("/vendor/"):
|
|
return "android-vendor"
|
|
if lower.startswith(("/system/", "/apex/")):
|
|
return "android-system"
|
|
if "/files/components/" in lower or "/files/system_vulkan/" in lower:
|
|
return "droiddeck-component"
|
|
if "/steamapps/common/" in lower:
|
|
return "steam-tool"
|
|
if lower.startswith(("/usr/", "/lib/", "/opt/")):
|
|
return "guest-runtime"
|
|
if lower.startswith("/tmp/"):
|
|
return "temporary"
|
|
return "other"
|
|
|
|
|
|
def library_identity(name, origin):
|
|
if origin in {"android-vendor", "android-system"}:
|
|
return name
|
|
base = name
|
|
while True:
|
|
head, separator, tail = base.rpartition(".")
|
|
if not separator or not tail.isdigit():
|
|
break
|
|
base = head
|
|
if name.lower() in WINDOWS_GRAPHICS_LIBRARIES or base in KNOWN_GRAPHICS_SONAMES:
|
|
return name
|
|
return "sha256:" + hashlib.sha256(name.encode()).hexdigest()[:16]
|
|
|
|
|
|
def graphics_libraries(maps_path):
|
|
libraries = set()
|
|
total = 0
|
|
lines = 0
|
|
with maps_path.open("rb") as source:
|
|
while lines < MAX_MAP_LINES and total < MAX_MAP_BYTES:
|
|
raw = source.readline(min(64 * 1024, MAX_MAP_BYTES - total + 1))
|
|
if not raw:
|
|
break
|
|
total += len(raw)
|
|
lines += 1
|
|
if total > MAX_MAP_BYTES:
|
|
return libraries, "capped"
|
|
parts = raw.decode("utf-8", "replace").rstrip("\n").split(None, 5)
|
|
if len(parts) < 6 or not parts[5].startswith("/"):
|
|
continue
|
|
mapped = parts[5].removesuffix(" (deleted)")
|
|
name = os.path.basename(mapped)
|
|
if SAFE_LIBRARY.fullmatch(name) and is_graphics_library(name):
|
|
origin = origin_class(mapped)
|
|
libraries.add((library_identity(name, origin), origin))
|
|
if len(libraries) >= MAX_LIBRARIES:
|
|
return libraries, "capped"
|
|
return libraries, "readable"
|
|
|
|
|
|
class Collector:
|
|
def __init__(self, proc_root, root_pid):
|
|
self.proc_root = Path(proc_root)
|
|
self.root_pid = int(root_pid)
|
|
self.known = {}
|
|
self.tokens = {}
|
|
self.next_token = 1
|
|
self.self_pid = os.getpid()
|
|
self.root_identity = None
|
|
self.last_maps_state = None
|
|
self.last_provider_error = None
|
|
|
|
def _scan_fallback(self, result):
|
|
capped = False
|
|
try:
|
|
entries = self.proc_root.iterdir()
|
|
except OSError:
|
|
return capped, "proc-unavailable"
|
|
examined = 0
|
|
for entry in entries:
|
|
if not entry.name.isdigit():
|
|
continue
|
|
examined += 1
|
|
if examined > MAX_ENUMERATED_PROCESSES:
|
|
capped = True
|
|
break
|
|
pid = int(entry.name)
|
|
if pid == self.self_pid or pid in result:
|
|
continue
|
|
try:
|
|
result[pid] = process_stat(entry / "stat")
|
|
except (OSError, ValueError):
|
|
continue
|
|
return capped, None
|
|
|
|
def _stats(self):
|
|
result = {}
|
|
capped = False
|
|
try:
|
|
ppid, start = process_stat(self.proc_root / str(self.root_pid) / "stat")
|
|
if self.root_pid != self.self_pid:
|
|
result[self.root_pid] = (ppid, start)
|
|
except (OSError, ValueError):
|
|
return result, capped, "proc-unavailable", "children", True
|
|
queue = [self.root_pid]
|
|
fallback = False
|
|
while queue and len(result) < MAX_PROCESSES:
|
|
parent = queue.pop(0)
|
|
try:
|
|
raw = bounded_bytes(
|
|
self.proc_root / str(parent) / "task" / str(parent) / "children", MAX_CHILDREN_BYTES + 1,
|
|
)
|
|
except OSError:
|
|
fallback = True
|
|
continue
|
|
if len(raw) > MAX_CHILDREN_BYTES:
|
|
capped = True
|
|
fallback = True
|
|
continue
|
|
for value in raw.split():
|
|
if not value.isdigit():
|
|
continue
|
|
pid = int(value)
|
|
if pid == self.self_pid or pid in result:
|
|
continue
|
|
if len(result) >= MAX_PROCESSES:
|
|
capped = True
|
|
break
|
|
try:
|
|
identity = process_stat(self.proc_root / str(pid) / "stat")
|
|
except (OSError, ValueError):
|
|
continue
|
|
if identity[0] != parent:
|
|
continue
|
|
result[pid] = identity
|
|
queue.append(pid)
|
|
if queue:
|
|
capped = True
|
|
if fallback:
|
|
fallback_capped, error = self._scan_fallback(result)
|
|
capped = capped or fallback_capped
|
|
return result, capped, error, "children+scan-fallback", True
|
|
return result, capped, None, "children", capped
|
|
|
|
def scan(self):
|
|
stats, enumeration_capped, provider_error, scope_method, scope_incomplete = self._stats()
|
|
descendants = set()
|
|
root = stats.get(self.root_pid)
|
|
if self.root_identity is None and root is not None:
|
|
self.root_identity = root
|
|
if root is not None and self.root_identity != root:
|
|
provider_error = "root-reused"
|
|
elif root is not None:
|
|
descendants.add(self.root_pid)
|
|
changed = True
|
|
while changed and len(descendants) < MAX_PROCESSES:
|
|
changed = False
|
|
for pid, (ppid, _) in stats.items():
|
|
if pid not in descendants and ppid in descendants:
|
|
descendants.add(pid)
|
|
changed = True
|
|
if len(descendants) >= MAX_PROCESSES:
|
|
break
|
|
if provider_error is None and root is None:
|
|
provider_error = "root-unavailable"
|
|
scope_capped = len(descendants) >= MAX_PROCESSES or enumeration_capped
|
|
current = {}
|
|
maps_state = {"readable": 0, "unavailable": 0, "capped": 0}
|
|
for pid in sorted(descendants):
|
|
process = self.proc_root / str(pid)
|
|
try:
|
|
expected = stats[pid]
|
|
if process_stat(process / "stat") != expected:
|
|
continue
|
|
ppid, start = expected
|
|
comm = (process / "comm").read_text(errors="replace")[:128].strip()
|
|
cmdline = bounded_bytes(process / "cmdline", MAX_CMDLINE_BYTES)
|
|
except (OSError, ValueError):
|
|
continue
|
|
key = (pid, start)
|
|
try:
|
|
libraries, state = graphics_libraries(process / "maps")
|
|
except (OSError, ValueError):
|
|
libraries, state = set(), "unavailable"
|
|
maps_state[state] = maps_state.get(state, 0) + 1
|
|
current[key] = {
|
|
"ppid": ppid,
|
|
"role": process_role(comm, cmdline),
|
|
"libraries": libraries,
|
|
"identity": expected,
|
|
"mapState": state,
|
|
}
|
|
stable = {}
|
|
for key, process in current.items():
|
|
pid = key[0]
|
|
try:
|
|
if process_stat(self.proc_root / str(pid) / "stat") != process["identity"]:
|
|
continue
|
|
except (OSError, ValueError):
|
|
continue
|
|
stable[key] = process
|
|
final = {}
|
|
valid_pids = {self.root_pid} if any(key[0] == self.root_pid for key in stable) else set()
|
|
changed = True
|
|
while changed:
|
|
changed = False
|
|
for key, process in stable.items():
|
|
pid = key[0]
|
|
if key not in final and (pid == self.root_pid or process["ppid"] in valid_pids):
|
|
final[key] = process
|
|
valid_pids.add(pid)
|
|
changed = True
|
|
current = final
|
|
try:
|
|
root_final = process_stat(self.proc_root / str(self.root_pid) / "stat")
|
|
except (OSError, ValueError):
|
|
root_final = None
|
|
if root_final is None:
|
|
if provider_error is None:
|
|
provider_error = "root-unavailable"
|
|
current = {}
|
|
elif self.root_identity != root_final:
|
|
provider_error = "root-reused"
|
|
current = {}
|
|
maps_state = {"readable": 0, "unavailable": 0, "capped": 0}
|
|
for process in current.values():
|
|
state = process["mapState"]
|
|
maps_state[state] = maps_state.get(state, 0) + 1
|
|
started = sorted(set(current) - set(self.known))
|
|
exited = sorted(set(self.known) - set(current))
|
|
roles_changed = any(
|
|
key in self.known and current[key]["role"] != self.known[key]["role"] for key in current
|
|
)
|
|
for key in started:
|
|
self.tokens[key] = self.next_token
|
|
self.next_token += 1
|
|
state_changed = maps_state != self.last_maps_state or provider_error != self.last_provider_error
|
|
payload = self._snapshot(
|
|
current, started, exited, maps_state, scope_capped, provider_error, scope_method, scope_incomplete,
|
|
)
|
|
for key in exited:
|
|
self.tokens.pop(key, None)
|
|
self.known = current
|
|
self.last_maps_state = maps_state
|
|
self.last_provider_error = provider_error
|
|
return payload, bool(started or exited or roles_changed or payload["librariesChanged"] or state_changed)
|
|
|
|
def _snapshot(self, current, started, exited, maps_state, scope_capped, provider_error,
|
|
scope_method, scope_incomplete):
|
|
previous_libraries = {item for process in self.known.values() for item in process["libraries"]}
|
|
libraries = {item for process in current.values() for item in process["libraries"]}
|
|
role_counts = {}
|
|
for process in current.values():
|
|
role = process["role"]
|
|
role_counts[role] = role_counts.get(role, 0) + 1
|
|
started_rows = [{"token": self.tokens[key], "role": current[key]["role"]} for key in started[:32]]
|
|
exited_rows = [{"token": self.tokens.get(key, 0), "role": self.known[key]["role"]} for key in exited[:32]]
|
|
library_rows = [{"name": name, "origin": origin} for name, origin in sorted(libraries)[:MAX_LIBRARIES]]
|
|
return {
|
|
"schema": SCHEMA,
|
|
"event": "snapshot",
|
|
"scope": "root-descendants",
|
|
"scopeMethod": scope_method,
|
|
"scopeIncomplete": scope_incomplete,
|
|
"procView": "guest-visible",
|
|
"alive": len(current),
|
|
"roles": role_counts,
|
|
"started": started_rows,
|
|
"startedOmitted": max(0, len(started) - len(started_rows)),
|
|
"exited": exited_rows,
|
|
"exitedOmitted": max(0, len(exited) - len(exited_rows)),
|
|
"libraries": library_rows,
|
|
"librariesOmitted": max(0, len(libraries) - len(library_rows)),
|
|
"librariesChanged": libraries != previous_libraries,
|
|
"maps": maps_state,
|
|
"scopeCapped": scope_capped,
|
|
"providerStatus": provider_error or "available",
|
|
}
|
|
|
|
|
|
def parse_args(argv):
|
|
parser = argparse.ArgumentParser()
|
|
parser.add_argument("--once", action="store_true")
|
|
parser.add_argument("--watch", action="store_true")
|
|
parser.add_argument("--root-pid", type=int, default=os.getppid())
|
|
parser.add_argument("--proc-root", default="/proc")
|
|
parser.add_argument("--interval-ms", type=int, default=DEFAULT_INTERVAL_MS)
|
|
parser.add_argument("--duration-ms", type=int, default=DEFAULT_DURATION_MS)
|
|
parser.add_argument("--max-records", type=int, default=DEFAULT_MAX_RECORDS)
|
|
args = parser.parse_args(argv)
|
|
if args.once == args.watch:
|
|
parser.error("choose exactly one of --once or --watch")
|
|
if args.root_pid <= 0:
|
|
parser.error("--root-pid must be positive")
|
|
args.interval_ms = min(60_000, max(250, args.interval_ms))
|
|
args.duration_ms = min(DEFAULT_DURATION_MS, max(0, args.duration_ms))
|
|
args.max_records = min(1_024, max(3, args.max_records))
|
|
return args
|
|
|
|
|
|
def main(argv=None, environ=None, output=sys.stdout):
|
|
environ = os.environ if environ is None else environ
|
|
if environ.get("DROIDDECK_ENHANCED_DIAGNOSTICS") != "1":
|
|
return 0
|
|
args = parse_args(sys.argv[1:] if argv is None else argv)
|
|
collector = Collector(args.proc_root, args.root_pid)
|
|
emit({
|
|
"schema": SCHEMA,
|
|
"event": "provider",
|
|
"mode": "once" if args.once else "watch",
|
|
"intervalMs": args.interval_ms,
|
|
"durationMs": 0 if args.once else args.duration_ms,
|
|
"maxRecords": args.max_records,
|
|
"scope": "root-descendants",
|
|
"procView": "guest-visible",
|
|
}, output)
|
|
records = 1
|
|
started = time.monotonic()
|
|
last_heartbeat = started
|
|
ended_normally = False
|
|
while records < args.max_records - 1:
|
|
payload, changed = collector.scan()
|
|
now = time.monotonic()
|
|
if changed or records == 1 or (now - last_heartbeat) * 1000 >= HEARTBEAT_MS:
|
|
if not changed and records > 1:
|
|
payload["event"] = "heartbeat"
|
|
payload.pop("libraries", None)
|
|
payload["librariesUnchanged"] = True
|
|
payload["elapsedMs"] = int((now - started) * 1000)
|
|
emit(payload, output)
|
|
records += 1
|
|
last_heartbeat = now
|
|
if args.once or payload["providerStatus"] in {"root-unavailable", "root-reused"} or \
|
|
(now - started) * 1000 >= args.duration_ms:
|
|
ended_normally = True
|
|
break
|
|
time.sleep(args.interval_ms / 1000)
|
|
if not ended_normally:
|
|
emit({"schema": SCHEMA, "event": "limit", "reason": "max-records"}, output)
|
|
return 0
|
|
|
|
|
|
if __name__ == "__main__":
|
|
raise SystemExit(main())
|