From 5614bd5d5aa1cf1cbb8a98e20ca392500b272819 Mon Sep 17 00:00:00 2001 From: wallentx Date: Wed, 4 Nov 2026 12:00:14 -0600 Subject: [PATCH] Add enhanced one-session diagnostic bundles --- .gitattributes | 1 + .../droiddeck/launcher/FrontEndActivity.kt | 48 +- .../com/droiddeck/launcher/SessionActivity.kt | 32 +- .../droiddeck/launcher/core/LogRedactor.kt | 64 +- .../launcher/session/EnhancedDiagnostics.kt | 118 +++ .../session/EnhancedSessionLogShare.kt | 731 ++++++++++++++++++ .../launcher/session/GameEnvironmentStore.kt | 3 +- .../launcher/session/SessionFiles.kt | 1 + .../launcher/session/SessionLogShare.kt | 111 +-- .../launcher/session/SessionPaths.kt | 9 +- .../launcher/session/SessionPrefs.kt | 14 +- .../launcher/session/SessionService.kt | 2 + .../launcher/session/SettingsReset.kt | 2 +- .../droiddeck/launcher/ui/FrontEndScreen.kt | 2 + .../droiddeck/launcher/ui/FrontEndSetup.kt | 4 + app/src/main/res/values/strings.xml | 7 + .../launcher/core/LogRedactorTest.kt | 54 ++ .../session/EnhancedDiagnosticsTest.kt | 140 ++++ .../session/EnhancedSessionLogShareTest.kt | 331 ++++++++ .../launcher/session/SessionLogShareTest.kt | 13 +- .../session/SessionLogShareZipTest.kt | 23 +- .../launcher/session/SettingsResetTest.kt | 2 + docs/development/game-environment.md | 42 + .../0900-enhanced-frame-diagnostics.patch | 333 ++++++++ .../local/bin/droiddeck-diagnostic-inventory | 446 +++++++++++ .../overlay/usr/local/bin/droiddeck-game-env | 60 +- .../overlay/usr/local/bin/droiddeck-session | 25 +- tools/tests/test_diagnostic_inventory.py | 234 ++++++ .../test_diagnostic_session_integration.py | 50 ++ tools/tests/test_game_exit_diagnostics.py | 186 +++++ tools/tests/test_gamescope_diagnostics.py | 133 ++++ tools/tests/test_steam_exit_status.py | 20 +- 32 files changed, 3100 insertions(+), 141 deletions(-) create mode 100644 app/src/main/java/com/droiddeck/launcher/session/EnhancedDiagnostics.kt create mode 100644 app/src/main/java/com/droiddeck/launcher/session/EnhancedSessionLogShare.kt create mode 100644 app/src/test/java/com/droiddeck/launcher/session/EnhancedDiagnosticsTest.kt create mode 100644 app/src/test/java/com/droiddeck/launcher/session/EnhancedSessionLogShareTest.kt create mode 100644 tools/gamescope/patches/0900-enhanced-frame-diagnostics.patch create mode 100755 tools/linuxfs/overlay/usr/local/bin/droiddeck-diagnostic-inventory create mode 100644 tools/tests/test_diagnostic_inventory.py create mode 100644 tools/tests/test_diagnostic_session_integration.py create mode 100644 tools/tests/test_game_exit_diagnostics.py create mode 100644 tools/tests/test_gamescope_diagnostics.py diff --git a/.gitattributes b/.gitattributes index 4c0a6c3120..940dbb5f13 100644 --- a/.gitattributes +++ b/.gitattributes @@ -2,6 +2,7 @@ tools/linuxfs/** text=auto eol=lf tools/mangoapp/** text=auto eol=lf tools/comet/LICENSE whitespace=-blank-at-eof tools/comet/droiddeck.patch whitespace=-blank-at-eol,-blank-at-eof +tools/gamescope/patches/0900-enhanced-frame-diagnostics.patch whitespace=-blank-at-eol,-blank-at-eof,-space-before-tab tools/linuxfs/overlay/** text eol=lf tools/linuxfs/desktop/** text eol=lf diff --git a/app/src/main/java/com/droiddeck/launcher/FrontEndActivity.kt b/app/src/main/java/com/droiddeck/launcher/FrontEndActivity.kt index 7bbac41b2f..cc9488b094 100644 --- a/app/src/main/java/com/droiddeck/launcher/FrontEndActivity.kt +++ b/app/src/main/java/com/droiddeck/launcher/FrontEndActivity.kt @@ -577,6 +577,7 @@ class FrontEndActivity : ComponentActivity() { private var emulatorList by mutableStateOf>(emptyList()) private var runningLabel by mutableStateOf(null) private var logsEnabled by mutableStateOf(true) + private var enhancedDiagnosticsArmed by mutableStateOf(false) private var gameDebugLogsEnabled by mutableStateOf(false) private var gameDebugLogsNeedsRestart by mutableStateOf(false) private var vacDiagnostics by mutableStateOf(false) @@ -1136,6 +1137,7 @@ class FrontEndActivity : ComponentActivity() { desktopInstalled = desktopInstalled, desktopPresent = desktopPresent, offlineAccount = offlineAccount, offline = offline, frameGenLabel = frameGenLabel, romsDir = romsDir, logsEnabled = logsEnabled, + enhancedDiagnosticsArmed = enhancedDiagnosticsArmed, gameDebugLogsEnabled = gameDebugLogsEnabled, gameDebugLogsNeedsRestart = gameDebugLogsNeedsRestart, vacDiagnostics = vacDiagnostics, agentCommands = agentCommands, clearCachedApps = clearCachedApps, adbPaired = adbPaired, memoryHud = memoryHud, backgroundAppLimit = backgroundAppLimit, @@ -1327,6 +1329,15 @@ class FrontEndActivity : ComponentActivity() { gameDebugLogsEnabled = SessionPrefs.gameDebugLogsEnabled(this) gameDebugLogsNeedsRestart = gameDebugLogsNeedsRestart() }, + onEnhancedDiagnostics = { + val requested = !com.droiddeck.launcher.session.EnhancedDiagnostics.isArmed(this) + if (!com.droiddeck.launcher.session.EnhancedDiagnostics.setArmed(this, requested)) { + android.widget.Toast.makeText( + this, R.string.setup_logging_update_failed, android.widget.Toast.LENGTH_LONG, + ).show() + } + enhancedDiagnosticsArmed = com.droiddeck.launcher.session.EnhancedDiagnostics.isArmed(this) + }, onGameDebugLogs = { val changed = SessionPrefs.setGameDebugLogsEnabled(this, !SessionPrefs.gameDebugLogsEnabled(this)) if (!changed) android.widget.Toast.makeText( @@ -1350,9 +1361,19 @@ class FrontEndActivity : ComponentActivity() { if (limit == com.droiddeck.launcher.core.BackgroundAppLimit.OFF) com.droiddeck.launcher.core.BackgroundAppLimit.restoreAsync(this) }, onShareLogs = { - SessionLogShare.prepare(this, { SessionLogShare.latest(this) }) { zip -> - if (zip == null) android.widget.Toast.makeText(this, R.string.main_no_logs_yet, android.widget.Toast.LENGTH_LONG).show() - else startActivity(SessionLogShare.shareIntent(this, zip)) + val folder = SessionLogShare.latest(this) + if (folder == null) { + android.widget.Toast.makeText(this, R.string.main_no_logs_yet, android.widget.Toast.LENGTH_LONG).show() + } else if (com.droiddeck.launcher.session.EnhancedDiagnostics.isActive(this, folder)) { + SessionLogShare.prepareEnhanced(this, { folder }) { zips -> + if (zips.isEmpty()) android.widget.Toast.makeText(this, R.string.main_no_logs_yet, android.widget.Toast.LENGTH_LONG).show() + else shareEnhancedArchives(zips) + } + } else { + SessionLogShare.prepare(this, { folder }) { zip -> + if (zip == null) android.widget.Toast.makeText(this, R.string.main_no_logs_yet, android.widget.Toast.LENGTH_LONG).show() + else startActivity(SessionLogShare.shareIntent(this, zip)) + } } }, onShareSessionLog = { folder -> @@ -2688,6 +2709,26 @@ class FrontEndActivity : ComponentActivity() { SessionPrefs.logsEnabled(this) && SessionPrefs.gameDebugLogsEnabled(this) && !SessionPaths.currentSessionLogsRetained(this) + private fun shareEnhancedArchives(zips: List) { + val choices = zips.map { zip -> + val label = when { + zip.name.endsWith("-session.zip") -> getString(R.string.diagnostics_share_session) + zip.name.endsWith("-graphics.zip") -> getString(R.string.diagnostics_share_graphics) + else -> getString(R.string.diagnostics_share_games) + } + label to listOf(zip) + } + (getString(R.string.diagnostics_share_all) to zips) + android.app.AlertDialog.Builder(this) + .setTitle(R.string.diagnostics_share_title) + .setItems(choices.map { it.first }.toTypedArray()) { _, which -> + val selected = choices[which].second + startActivity(if (selected.size == 1) SessionLogShare.shareIntent(this, selected.single()) + else SessionLogShare.shareEnhancedIntent(this, selected)) + } + .setNegativeButton(android.R.string.cancel, null) + .show() + } + private fun refresh() { val listX64 = SessionPrefs.activeSteamClientArch(this) == "x86_64" if (listX64 != steamGamesX64) { @@ -2712,6 +2753,7 @@ class FrontEndActivity : ComponentActivity() { frameGenLabel = FrameGen.label(this) romsDir = SessionPrefs.romsDir(this).takeIf { it.isNotEmpty() } logsEnabled = SessionPrefs.logsEnabled(this) + enhancedDiagnosticsArmed = com.droiddeck.launcher.session.EnhancedDiagnostics.isArmed(this) gameDebugLogsEnabled = SessionPrefs.gameDebugLogsEnabled(this) gameDebugLogsNeedsRestart = gameDebugLogsNeedsRestart() vacDiagnostics = SessionPrefs.vacDiagnostics(this) diff --git a/app/src/main/java/com/droiddeck/launcher/SessionActivity.kt b/app/src/main/java/com/droiddeck/launcher/SessionActivity.kt index b4968c7110..d5c4fe3104 100644 --- a/app/src/main/java/com/droiddeck/launcher/SessionActivity.kt +++ b/app/src/main/java/com/droiddeck/launcher/SessionActivity.kt @@ -1884,7 +1884,17 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback { Toast.makeText(this, R.string.session_no_logs, Toast.LENGTH_LONG).show() return } - SessionLogShare.prepare(this, { folder }) { zip -> + if (com.droiddeck.launcher.session.EnhancedDiagnostics.isActive(this, folder)) { + SessionLogShare.prepareEnhanced(this, { folder }) { zips -> + if (zips.isEmpty()) { + Toast.makeText(this, R.string.session_logs_archive_failed, Toast.LENGTH_LONG).show() + } else runCatching { shareEnhancedArchives(zips) } + .onFailure { + Log.w(TAG, "could not share current session logs", it) + Toast.makeText(this, R.string.session_logs_share_failed, Toast.LENGTH_LONG).show() + } + } + } else SessionLogShare.prepare(this, { folder }) { zip -> if (zip == null) { Toast.makeText(this, R.string.session_logs_archive_failed, Toast.LENGTH_LONG).show() } else { @@ -1897,6 +1907,26 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback { } } + private fun shareEnhancedArchives(zips: List) { + val choices = zips.map { zip -> + val label = when { + zip.name.endsWith("-session.zip") -> getString(R.string.diagnostics_share_session) + zip.name.endsWith("-graphics.zip") -> getString(R.string.diagnostics_share_graphics) + else -> getString(R.string.diagnostics_share_games) + } + label to listOf(zip) + } + (getString(R.string.diagnostics_share_all) to zips) + android.app.AlertDialog.Builder(this) + .setTitle(R.string.diagnostics_share_title) + .setItems(choices.map { it.first }.toTypedArray()) { _, which -> + val selected = choices[which].second + startActivity(if (selected.size == 1) SessionLogShare.shareIntent(this, selected.single()) + else SessionLogShare.shareEnhancedIntent(this, selected)) + } + .setNegativeButton(android.R.string.cancel, null) + .show() + } + private fun readPrefs() { pipAutoEnter = SessionPrefs.pipAutoEnter(this) unfoldedControls = SessionPrefs.unfoldedControls(this) diff --git a/app/src/main/java/com/droiddeck/launcher/core/LogRedactor.kt b/app/src/main/java/com/droiddeck/launcher/core/LogRedactor.kt index 3230e8ea47..19199873f7 100644 --- a/app/src/main/java/com/droiddeck/launcher/core/LogRedactor.kt +++ b/app/src/main/java/com/droiddeck/launcher/core/LogRedactor.kt @@ -131,42 +131,81 @@ object LogRedactor { @Volatile private var accounts: List = emptyList() - fun learnAccounts(vararg loginUsers: java.io.File) { + internal const val MAX_LEARN_INPUT_BYTES = 2 * 1024 * 1024 + private const val MAX_LEARNED_ACCOUNTS = 2048 + private const val MAX_LEARNED_ADDRESSES = 1024 + private const val MAX_ACCOUNT_LENGTH = 256 + + private fun boundedText(file: java.io.File): String? = try { + file.inputStream().buffered().use { input -> + val out = java.io.ByteArrayOutputStream() + val buffer = ByteArray(16 * 1024) + var remaining = MAX_LEARN_INPUT_BYTES + while (remaining > 0) { + val read = input.read(buffer, 0, minOf(buffer.size, remaining)) + if (read < 0) return out.toString(Charsets.UTF_8.name()) + if (read == 0) continue + out.write(buffer, 0, read) + remaining -= read + } + if (input.read() != -1) null else out.toString(Charsets.UTF_8.name()) + } + } catch (_: Exception) { + null + } + + fun learnAccounts(vararg loginUsers: java.io.File): Boolean { val names = LinkedHashSet() val kv = Regex("\"(AccountName|PersonaName)\"\\s+\"([^\"]*)\"") var unread = false for (file in loginUsers) { if (!file.isFile) continue - val text = try { file.readText() } catch (e: Exception) { unread = true; continue } - kv.findAll(text).map { it.groupValues[2].trim() }.filter { it.length >= 3 }.forEach { names += it } + val text = boundedText(file) + if (text == null) { + unread = true + continue + } + for (match in kv.findAll(text)) { + val name = match.groupValues[2].trim() + if (name.length < 3) continue + if (name.length > MAX_ACCOUNT_LENGTH || names.size >= MAX_LEARNED_ACCOUNTS) { + unread = true + break + } + names += name + } } val learned = names.map { name -> val needs = name.lowercase().takeIf { name.all { it.code < 0x80 } } Learned(Regex("(?i)(? = emptyList() - fun learnOwnAddresses(linkFile: java.io.File) { + fun learnOwnAddresses(linkFile: java.io.File): Boolean { val found = ArrayList() try { - if (linkFile.isFile) linkFile.forEachLine { line -> - val addr = line.trim().takeIf { it.startsWith("addr ") }?.split(Regex("\\s+"))?.getOrNull(1) ?: return@forEachLine + val text = if (linkFile.isFile) boundedText(linkFile) ?: return false else "" + text.lineSequence().forEach { line -> + val addr = line.trim().takeIf { it.startsWith("addr ") }?.split(Regex("\\s+"))?.getOrNull(1) ?: return@forEach + if (found.size >= MAX_LEARNED_ADDRESSES) return false when (kind(addr)) { "public IPv6" -> { - val groups = expand6(addr)?.take(4) ?: return@forEachLine + val groups = expand6(addr)?.take(4) ?: return@forEach val prefix = groups.joinToString(":") { g -> "0{0,3}" + Regex.escape(g.trimStart('0').ifEmpty { "0" }) } found += Learned( Regex("(?i)(? + if (!File(known).isDirectory) records.remove(known) + } + records.put(path, activatedAt) + return context.getSharedPreferences(PREFS, Context.MODE_PRIVATE).edit() + .putString(ACTIVE_RECORDS, records.toString()) + .putBoolean(ARMED, false) + .commit() + } + + private fun removeRecord(context: Context, folder: File) { + val path = runCatching { folder.canonicalPath }.getOrNull() ?: return + val records = records(context) + if (records.has(path)) { + records.remove(path) + saveRecords(context, records) + } + } + + private fun trustedPath(context: Context, folder: File?): String? { + if (folder == null || !SessionPaths.isSessionFolder(folder)) return null + return runCatching { + val canonical = folder.canonicalFile + if (canonical.parentFile != SessionFiles.logDirectory(context).canonicalFile) null else canonical.path + }.getOrNull() + } + + private fun records(context: Context): JSONObject { + val text = context.getSharedPreferences(PREFS, Context.MODE_PRIVATE).getString(ACTIVE_RECORDS, null) + return runCatching { JSONObject(text ?: "{}") }.getOrDefault(JSONObject()) + } + + private fun saveRecords(context: Context, records: JSONObject): Boolean = + context.getSharedPreferences(PREFS, Context.MODE_PRIVATE).edit() + .putString(ACTIVE_RECORDS, records.toString()).commit() +} diff --git a/app/src/main/java/com/droiddeck/launcher/session/EnhancedSessionLogShare.kt b/app/src/main/java/com/droiddeck/launcher/session/EnhancedSessionLogShare.kt new file mode 100644 index 0000000000..6d6f357d70 --- /dev/null +++ b/app/src/main/java/com/droiddeck/launcher/session/EnhancedSessionLogShare.kt @@ -0,0 +1,731 @@ +package com.droiddeck.launcher.session + +import android.content.Context +import android.os.ParcelFileDescriptor +import android.system.Os +import android.system.OsConstants +import com.droiddeck.launcher.core.LogRedactor +import com.droiddeck.launcher.runtime.BattleNet +import com.droiddeck.launcher.runtime.LinuxRuntime +import org.json.JSONArray +import org.json.JSONObject +import java.io.ByteArrayOutputStream +import java.io.File +import java.io.FileOutputStream +import java.io.FileInputStream +import java.nio.ByteBuffer +import java.nio.channels.Channels +import java.nio.channels.FileChannel +import java.nio.channels.SeekableByteChannel +import java.nio.file.Files +import java.nio.file.LinkOption +import java.nio.file.Path +import java.security.MessageDigest +import java.util.Locale +import java.util.zip.ZipEntry +import java.util.zip.ZipOutputStream + +internal data class EnhancedShareLimits( + val maxFilesPerArchive: Int = 256, + val maxDiscoveredFiles: Int = 768, + val maxBytesPerFile: Long = 8L * 1024 * 1024, + val maxBytesTotal: Long = 64L * 1024 * 1024, +) + +internal object EnhancedSessionLogShare { + private enum class Category(val suffix: String) { SESSION("session"), GRAPHICS("graphics"), GAMES("games") } + + private data class Candidate( + val file: File, + val anchor: File, + val entry: String, + val origin: String, + val category: Category, + val linePrefix: String? = null, + ) + + private data class Record( + val entry: String, + val origin: String, + val status: String, + val sourceBytes: Long = 0, + val capturedBytes: Long = 0, + val reason: String? = null, + ) + + private data class Snapshot(val file: File, val sourceBytes: Long, val truncated: Boolean) + + private data class CollectionResult(val candidates: List, val truncated: Boolean) + + private data class ScanResult(val files: List, val truncated: Boolean) + + private data class LegacySource(val file: File, val root: File, val entry: String) + + private class Budget(val limit: Long, var remaining: Long = limit) + + fun create( + context: Context, + folder: File, + onProgress: ((Float) -> Unit)? = null, + limits: EnhancedShareLimits = EnhancedShareLimits(), + ): List { + if (!folder.isDirectory || Files.isSymbolicLink(folder.toPath()) || + limits.maxFilesPerArchive < 1 || limits.maxBytesPerFile < 1 || limits.maxBytesTotal < 1) { + return emptyList() + } + val out = SessionLogShare.shareDir(context).apply { deleteRecursively(); mkdirs() } + val stage = File(out, ".diagnostic-stage").apply { mkdirs() } + val redactionLearningComplete = LogRedactor.learnFromRuntime(LinuxRuntime.rootDir(context)) + val discovery = collect(context, folder, limits.maxDiscoveredFiles, legacy = false) + val candidates = discovery.candidates + val totalCandidates = candidates.size.coerceAtLeast(1) + val share = limits.maxBytesTotal / Category.values().size + val budgets = Category.values().associateWith { category -> + Budget(if (category == Category.GAMES) limits.maxBytesTotal - share * 2 else share) + } + var completed = 0 + return try { + Category.values().map { category -> + val budget = budgets.getValue(category) + val records = ArrayList() + val selected = candidates.filter { it.category == category } + val zip = File(out, "DroidDeck-${folder.name}-${category.suffix}.zip") + ZipOutputStream(zip.outputStream().buffered()).use { archive -> + val names = HashSet() + selected.forEachIndexed { index, candidate -> + val safeEntry = safeEntry(candidate.entry) + val record = when { + index >= limits.maxFilesPerArchive -> Record( + safeEntry ?: "", candidate.origin, "omitted", reason = "file-count-limit", + ) + safeEntry == null -> Record("", candidate.origin, "omitted", reason = "unsafe-entry-name") + !names.add(safeEntry) -> Record(safeEntry, candidate.origin, "omitted", reason = "duplicate-entry") + else -> addCandidate(archive, candidate.copy(entry = safeEntry), stage, budget, limits) + } + records += record + completed++ + onProgress?.invoke((completed.toFloat() / totalCandidates).coerceIn(0f, 1f)) + } + if (category == Category.SESSION) addTrustedActivation(context, folder, archive)?.let(records::add) + if (selected.isEmpty()) records += Record("", category.suffix, "unavailable", reason = "no-matching-artifacts") + if (discovery.truncated) records += Record("", "discovery", "truncated", reason = "candidate-limit") + addManifest( + archive, folder.name, category.suffix, records, limits, budget.limit, redactionLearningComplete, + ) + } + zip + } + } finally { + stage.deleteRecursively() + } + } + + fun createLegacy( + context: Context, + folder: File, + onProgress: ((Float) -> Unit)? = null, + limits: EnhancedShareLimits = EnhancedShareLimits(maxFilesPerArchive = 512), + ): File? { + if (!folder.isDirectory || Files.isSymbolicLink(folder.toPath()) || + limits.maxFilesPerArchive < 1 || limits.maxBytesPerFile < 1 || limits.maxBytesTotal < 1) { + return null + } + val out = SessionLogShare.shareDir(context).apply { deleteRecursively(); mkdirs() } + val redactionLearningComplete = LogRedactor.learnFromRuntime(LinuxRuntime.rootDir(context)) + val discovery = collect(context, folder, limits.maxDiscoveredFiles, legacy = true) + val candidates = discovery.candidates.filter { it.linePrefix == null } + if (candidates.isEmpty()) { + out.deleteRecursively() + return null + } + val stage = File(out, ".diagnostic-stage").apply { mkdirs() } + val records = ArrayList() + val budget = Budget(limits.maxBytesTotal) + val zip = File(out, "DroidDeck-${folder.name}.zip") + return try { + ZipOutputStream(zip.outputStream().buffered()).use { archive -> + val names = HashSet() + candidates.forEachIndexed { index, candidate -> + val safeEntry = safeEntry(candidate.entry) + records += when { + index >= limits.maxFilesPerArchive -> Record( + safeEntry ?: "", candidate.origin, "omitted", reason = "file-count-limit", + ) + safeEntry == null -> Record("", candidate.origin, "omitted", reason = "unsafe-entry-name") + !names.add(safeEntry) -> Record(safeEntry, candidate.origin, "omitted", reason = "duplicate-entry") + else -> addCandidate(archive, candidate.copy(entry = safeEntry), stage, budget, limits) + } + onProgress?.invoke((index + 1f) / candidates.size) + } + addTrustedActivation(context, folder, archive)?.let(records::add) + if (discovery.truncated) records += Record("", "discovery", "truncated", reason = "candidate-limit") + addManifest(archive, folder.name, "all", records, limits, budget.limit, redactionLearningComplete) + } + zip + } finally { + stage.deleteRecursively() + } + } + + private fun addTrustedActivation( + context: Context, + folder: File, + archive: ZipOutputStream, + ): Record? { + val manifest = EnhancedDiagnostics.manifest(context, folder) ?: return null + val bytes = (manifest.toString(2) + "\n").toByteArray() + val entry = "${folder.name}/${EnhancedDiagnostics.MANIFEST_FILE}" + archive.putNextEntry(ZipEntry(entry)) + archive.write(bytes) + archive.closeEntry() + return Record(entry, "app-private-activation-state", "captured", bytes.size.toLong(), bytes.size.toLong()) + } + + private fun addCandidate( + archive: ZipOutputStream, + candidate: Candidate, + stage: File, + budget: Budget, + limits: EnhancedShareLimits, + ): Record { + if (budget.remaining <= 0) { + return Record(candidate.entry, candidate.origin, "omitted", reason = "bundle-byte-limit") + } + val snapshot = runCatching { + snapshot(candidate, stage, minOf(limits.maxBytesPerFile, budget.remaining)) + }.getOrElse { + return Record(candidate.entry, candidate.origin, "error", reason = it.javaClass.simpleName) + } ?: return Record(candidate.entry, candidate.origin, "omitted", reason = "unsafe-or-unavailable-source") + if (snapshot.file.length() == 0L && candidate.linePrefix != null) { + snapshot.file.delete() + return Record(candidate.entry, candidate.origin, "unavailable", snapshot.sourceBytes, reason = "no-matching-lines") + } + return try { + budget.remaining -= snapshot.file.length() + archive.putNextEntry(ZipEntry(candidate.entry)) + val writer = archive.bufferedWriter() + LogRedactor.scrubForShare(snapshot.file, writer) + writer.flush() + archive.closeEntry() + Record( + candidate.entry, + candidate.origin, + if (snapshot.truncated) "truncated" else "captured", + snapshot.sourceBytes, + snapshot.file.length(), + if (snapshot.truncated) "per-file-or-bundle-byte-limit" else null, + ) + } finally { + snapshot.file.delete() + } + } + + private fun snapshot(candidate: Candidate, stage: File, limit: Long): Snapshot? { + val rootPath = candidate.anchor.toPath().toAbsolutePath().normalize() + val sourcePath = candidate.file.toPath().toAbsolutePath().normalize() + if (!sourcePath.startsWith(rootPath) || sourcePath == rootPath || limit < 1) return null + val target = File.createTempFile("diagnostic-", ".log", stage) + try { + val relative = rootPath.relativize(sourcePath) + return withSecureChannel(rootPath, relative) { input -> + val size = input.size() + candidate.linePrefix?.let { prefix -> + val truncated = filterChannel(input, target, prefix, size, TRACE_SCAN_BYTES, limit) + return@withSecureChannel Snapshot(target, size, truncated) + } + FileOutputStream(target).channel.use { output -> + if (size <= limit) { + copy(input, output, 0, size) + } else { + val marker = "\n\n".toByteArray() + val content = (limit - marker.size).coerceAtLeast(0) + copyCompleteHead(input, output, content / 2) + val markerBytes = minOf(marker.size.toLong(), limit - output.position()).toInt() + output.write(ByteBuffer.wrap(marker, 0, markerBytes)) + copyCompleteTail(input, output, size, (limit - output.position()).coerceAtLeast(0)) + } + output.force(false) + } + Snapshot(target, size, size > limit) + } ?: target.delete().let { null } + } catch (e: Exception) { + target.delete() + throw e + } + } + + private fun filterChannel( + channel: SeekableByteChannel, + target: File, + prefix: String, + sourceSize: Long, + scanLimit: Long, + outputLimit: Long, + ): Boolean { + val wanted = prefix.toByteArray() + var written = 0L + var truncated = sourceSize > scanLimit + target.outputStream().buffered().use { output -> + fun scan(start: Long, count: Long, discardPartialFirstLine: Boolean) { + channel.position(start) + val input = Channels.newInputStream(channel) + val line = ByteArrayOutputStream(1024) + var oversized = false + var scanned = 0L + var discard = discardPartialFirstLine + fun emit() { + val bytes = line.toByteArray() + if (!discard && !oversized && bytes.size >= wanted.size && wanted.indices.all { bytes[it] == wanted[it] }) { + if (written + bytes.size + 1 <= outputLimit) { + output.write(bytes) + output.write('\n'.code) + written += bytes.size + 1 + } else truncated = true + } + line.reset() + oversized = false + discard = false + } + while (scanned < count) { + val value = input.read() + if (value < 0) break + scanned++ + if (value == '\n'.code) emit() + else if (!oversized && !discard) { + if (line.size() >= LogRedactor.MAX_LINE_LENGTH) { + oversized = true + line.reset() + } else line.write(value) + } + } + if (start + scanned >= sourceSize && (line.size() > 0 || oversized)) emit() + } + if (sourceSize <= scanLimit) { + scan(0, sourceSize, false) + } else { + val head = scanLimit / 2 + val tail = scanLimit - head + scan(0, head, false) + scan((sourceSize - tail).coerceAtLeast(0), tail, true) + } + } + return truncated + } + + private fun withSecureChannel(root: Path, relative: Path, block: (SeekableByteChannel) -> T): T? { + val opened = ArrayList() + return try { + val parts = relative.map { it.toString() } + if (parts.isEmpty()) return null + val rootFd = openDescriptor(root.toString()) ?: return null + if (!OsConstants.S_ISDIR(Os.fstat(rootFd).st_mode)) { + Os.close(rootFd) + return null + } + opened += duplicateAndClose(rootFd) + for (part in parts.dropLast(1)) { + val childFd = openDescriptor(procChild(opened.last(), part)) ?: return null + if (!OsConstants.S_ISDIR(Os.fstat(childFd).st_mode)) { + Os.close(childFd) + return null + } + opened += duplicateAndClose(childFd) + } + val leafFd = openDescriptor(procChild(opened.last(), parts.last())) ?: return null + val stat = Os.fstat(leafFd) + if (!OsConstants.S_ISREG(stat.st_mode) || stat.st_nlink != 1L) { + Os.close(leafFd) + return null + } + val stream = try { + FileInputStream(leafFd) + } catch (error: Exception) { + Os.close(leafFd) + throw error + } + stream.use { block(it.channel) } + } catch (_: Exception) { + null + } finally { + opened.asReversed().forEach { runCatching { it.close() } } + } + } + + private fun openDescriptor(path: String): java.io.FileDescriptor? = runCatching { + Os.open( + path, + OsConstants.O_RDONLY or OsConstants.O_CLOEXEC or OsConstants.O_NOFOLLOW or OsConstants.O_NONBLOCK, + 0, + ) + }.getOrNull() + + private fun duplicateAndClose(fd: java.io.FileDescriptor): ParcelFileDescriptor = + try { + ParcelFileDescriptor.dup(fd) + } finally { + Os.close(fd) + } + + private fun procChild(directory: ParcelFileDescriptor, name: String): String = + "/proc/self/fd/${directory.fd}/$name" + + private fun copy(input: SeekableByteChannel, output: FileChannel, start: Long, count: Long) { + input.position(start) + var left = count + val buffer = ByteBuffer.allocate(64 * 1024) + while (left > 0) { + buffer.clear() + buffer.limit(minOf(buffer.capacity().toLong(), left).toInt()) + val read = input.read(buffer) + if (read < 0) break + buffer.flip() + while (buffer.hasRemaining()) output.write(buffer) + left -= read + } + } + + private fun copyCompleteHead(input: SeekableByteChannel, output: FileChannel, limit: Long) { + if (limit <= 0) return + copy(input, output, 0, limit) + val copied = output.position() + input.position(0) + val buffer = ByteBuffer.allocate(64 * 1024) + var scanned = 0L + var lastComplete = 0L + while (scanned < copied) { + buffer.clear() + buffer.limit(minOf(buffer.capacity().toLong(), copied - scanned).toInt()) + val read = input.read(buffer) + if (read < 0) break + buffer.flip() + repeat(read) { index -> + if (buffer.get(index) == '\n'.code.toByte()) lastComplete = scanned + index + 1 + } + scanned += read + } + output.truncate(lastComplete) + output.position(lastComplete) + } + + private fun copyCompleteTail( + input: SeekableByteChannel, + output: FileChannel, + sourceSize: Long, + limit: Long, + ) { + if (limit <= 0 || sourceSize <= 0) return + var start = (sourceSize - limit).coerceAtLeast(0) + if (start > 0) { + input.position(start) + val one = ByteBuffer.allocate(1) + while (start < sourceSize) { + one.clear() + if (input.read(one) < 0) return + start++ + one.flip() + if (one.get() == '\n'.code.toByte()) break + } + } + copy(input, output, start, (sourceSize - start).coerceAtMost(limit)) + } + + private fun addManifest( + archive: ZipOutputStream, + sessionId: String, + category: String, + records: List, + limits: EnhancedShareLimits, + categoryBudget: Long, + redactionLearningComplete: Boolean, + ) { + val entries = JSONArray() + records.take(MAX_MANIFEST_RECORDS).forEach { record -> + entries.put(JSONObject().apply { + put("entry", record.entry) + put("origin", record.origin) + put("status", record.status) + put("sourceBytes", record.sourceBytes) + put("capturedBytes", record.capturedBytes) + record.reason?.let { put("reason", it) } + }) + } + if (records.size > MAX_MANIFEST_RECORDS) { + entries.put(JSONObject().apply { + put("entry", "") + put("origin", "manifest") + put("status", "omitted") + put("reason", "${records.size - MAX_MANIFEST_RECORDS} additional records") + }) + } + val manifest = JSONObject().apply { + put("schema", 1) + put("sessionId", sessionId) + put("category", category) + put("generatedAtMillis", System.currentTimeMillis()) + put("redactionLearning", if (redactionLearningComplete) "complete" else "incomplete") + put("limits", JSONObject().apply { + put("maxFilesPerArchive", limits.maxFilesPerArchive) + put("maxDiscoveredFiles", limits.maxDiscoveredFiles) + put("maxBytesPerFile", limits.maxBytesPerFile) + put("budgetBasis", "raw-input-snapshot-bytes") + put("maxRawInputBytesTotal", limits.maxBytesTotal) + put("categoryRawInputBudgetBytes", categoryBudget) + }) + put("entries", entries) + }.toString(2) + "\n" + archive.putNextEntry(ZipEntry("diagnostics-manifest.json")) + archive.write(manifest.toByteArray()) + archive.closeEntry() + } + + private fun collect(context: Context, folder: File, maxFiles: Int, legacy: Boolean): CollectionResult { + val out = LinkedHashMap() + val categoryCounts = HashMap() + val perCategory = (maxFiles / Category.values().size).coerceAtLeast(1) + var truncated = false + fun add( + file: File, + root: File, + entry: String, + origin: String, + forcedCategory: Category? = null, + linePrefix: String? = null, + ) { + val safe = safeEntry(entry) ?: return + val category = forcedCategory ?: category(entry) + if (out.size >= maxFiles || (categoryCounts[category] ?: 0) >= perCategory) { + truncated = true + return + } + val anchor = anchorFor(context, root) + if (out.putIfAbsent(safe, Candidate(file, anchor, safe, origin, category, linePrefix)) == null) { + categoryCounts[category] = (categoryCounts[category] ?: 0) + 1 + } + } + CRITICAL_SESSION_FILES.forEach { name -> + File(folder, name).takeIf { it.exists() }?.let { add(it, folder, "${folder.name}/$name", "session-critical") } + } + File(folder, "session.log").takeIf { it.exists() }?.let { file -> + add( + file, folder, "${folder.name}/graphics/frame-trace.log", "guest-frame-trace", + Category.GRAPHICS, "DROIDDECK_FRAME_TRACE ", + ) + add( + file, folder, "${folder.name}/graphics/process-trace.log", "guest-process-trace", + Category.GRAPHICS, "DROIDDECK_PROCESS_TRACE ", + ) + add( + file, folder, "${folder.name}/games/game-lifecycle.log", "guest-game-lifecycle", + Category.GAMES, "DROIDDECK_DIAGNOSTICS event=game_", + ) + } + if (SessionPaths.current()?.canonicalFile == folder.canonicalFile && !File(folder, "steam").exists()) { + val steam = File(SessionPrefs.activeSteamRoot(context), "logs") + val scan = directFiles(steam, remaining(maxFiles, out.size)) + truncated = truncated || scan.truncated + scan.files.forEach { + add(it, steam, "${folder.name}/steam/${it.name}", "live-steam") + } + } + val logs = LinuxRuntime.logDir(context) + for ((name, root) in listOf(SessionLogShare.STORES_DIR to File(logs, SessionLogShare.STORES_DIR), SessionPaths.TOOLS_DIR to File(logs, SessionPaths.TOOLS_DIR))) { + val scan = directFiles(root, remaining(maxFiles, out.size)) + truncated = truncated || scan.truncated + scan.files.asSequence().filter { recent(it) } + .forEach { add(it, root, "$name/${it.name}", name) } + } + if (legacy) { + legacyBattleNet(context).forEach { source -> + add(source.file, source.root, source.entry, "battlenet") + } + } else { + battleNetRoots(context).forEach { (prefix, root) -> + val scan = walk(root, remaining(maxFiles, out.size)) + truncated = truncated || scan.truncated + scan.files.asSequence().filter { recent(it) && it.name.endsWith(".log", true) } + .forEach { file -> + val relative = root.toPath().toAbsolutePath().normalize().relativize(file.toPath().toAbsolutePath().normalize()).joinToString("/") + add(file, root, "battlenet/$prefix/$relative", "battlenet") + } + } + } + val sessionScan = walk(folder, remaining(maxFiles, out.size)) + truncated = truncated || sessionScan.truncated + sessionScan.files.forEach { file -> + val relative = file.toPath().toAbsolutePath().normalize() + .let { folder.toPath().toAbsolutePath().normalize().relativize(it).joinToString("/") } + if (relative == EnhancedDiagnostics.MANIFEST_FILE) return@forEach + add(file, folder, "${folder.name}/$relative", "session") + } + return CollectionResult(out.values.toList(), truncated) + } + + private fun remaining(maxFiles: Int, found: Int): Int = (maxFiles - found + 1).coerceAtLeast(0) + + private fun walk(root: File, limit: Int): ScanResult { + if (limit <= 0 || !root.isDirectory || Files.isSymbolicLink(root.toPath())) return ScanResult(emptyList(), false) + val files = ArrayList(limit) + var truncated = false + Files.walk(root.toPath()).use { paths -> + val iterator = paths.iterator() + var visited = 0 + val visitLimit = (limit * 4).coerceAtLeast(limit).coerceAtMost(MAX_DISCOVERY_VISITS) + while (iterator.hasNext() && files.size < limit && visited < visitLimit) { + val path = iterator.next() + visited++ + if (path != root.toPath() && + (Files.isRegularFile(path, LinkOption.NOFOLLOW_LINKS) || Files.isSymbolicLink(path))) { + files += path.toFile() + } + } + truncated = iterator.hasNext() + } + return ScanResult(files, truncated) + } + + private fun directFiles(root: File, limit: Int): ScanResult { + if (limit <= 0 || !root.isDirectory || Files.isSymbolicLink(root.toPath())) return ScanResult(emptyList(), false) + val files = ArrayList(limit) + var truncated = false + Files.newDirectoryStream(root.toPath()).use { entries -> + val iterator = entries.iterator() + while (iterator.hasNext() && files.size < limit) { + val path = iterator.next() + if (Files.isRegularFile(path, LinkOption.NOFOLLOW_LINKS) || Files.isSymbolicLink(path)) { + files += path.toFile() + } + } + truncated = iterator.hasNext() + } + return ScanResult(files, truncated) + } + + private fun battleNetRoots(context: Context): List> { + val drive = File(BattleNet.prefix(context), "pfx/drive_c") + val data = File(drive, "ProgramData/Battle.net") + return listOf( + "droiddeck" to File(LinuxRuntime.rootDir(context), "root/.cache/droiddeck/battlenet"), + "client" to File(drive, "users/steamuser/AppData/Local/Battle.net/Logs"), + "agent" to File(data, "Agent"), + "setup" to File(data, "Setup"), + ) + } + + private fun legacyBattleNet(context: Context): List { + val drive = File(BattleNet.prefix(context), "pfx/drive_c") + val data = File(drive, "ProgramData/Battle.net") + val agent = File(data, "Agent") + val setup = File(data, "Setup") + return legacyNewest( + "droiddeck", + listOf(File(LinuxRuntime.rootDir(context), "root/.cache/droiddeck/battlenet")), + 2, + setOf("battlenet.log", "spawned.log"), + ) + legacyNewest( + "client", listOf(File(drive, "users/steamuser/AppData/Local/Battle.net/Logs")), 6, + ) + legacyNewest( + "agent", + listOf(File(agent, "Logs")) + childDirectories(agent, "Agent.").map { File(it, "Logs") }, + 10, + byDir = true, + ) + legacyNewest( + "setup", childDirectories(setup, "").map { File(it, "Logs") }, 3, byDir = true, + ) + } + + private fun legacyNewest( + folder: String, + roots: List, + count: Int, + names: Set? = null, + byDir: Boolean = false, + ): List = roots.flatMap { root -> + directFiles(root, MAX_BATTLENET_SCAN).files.asSequence() + .filter { recent(it) && it.name.endsWith(".log") && it.length() <= LEGACY_LOG_MAX_BYTES } + .filter { names == null || it.name in names } + .map { it to root } + .toList() + }.sortedByDescending { it.first.lastModified() }.take(count).map { (file, root) -> + val relative = if (byDir) "$folder/${file.parentFile?.parentFile?.name}/${file.name}" else "$folder/${file.name}" + LegacySource(file, root, "battlenet/$relative") + } + + private fun childDirectories(root: File, prefix: String): List { + if (!root.isDirectory || Files.isSymbolicLink(root.toPath())) return emptyList() + val found = ArrayList() + Files.newDirectoryStream(root.toPath()).use { entries -> + val iterator = entries.iterator() + while (iterator.hasNext() && found.size < MAX_BATTLENET_DIRECTORIES) { + val path = iterator.next() + if (path.fileName.toString().startsWith(prefix) && + Files.isDirectory(path, LinkOption.NOFOLLOW_LINKS) && !Files.isSymbolicLink(path)) found += path.toFile() + } + } + return found + } + + private fun recent(file: File): Boolean = file.lastModified() >= System.currentTimeMillis() - RECENT_MILLIS + + private fun anchorFor(context: Context, root: File): File { + val path = root.toPath().toAbsolutePath().normalize() + for (anchor in listOf(context.filesDir, context.cacheDir)) { + if (path.startsWith(anchor.toPath().toAbsolutePath().normalize())) return anchor + } + return root.parentFile ?: root + } + + private fun safeEntry(name: String): String? { + if (name.any { it.code < 0x20 || it.code == 0x7f }) return null + val normalized = name.replace('\\', '/').trimStart('/') + val parts = normalized.split('/') + if (normalized.isEmpty() || parts.any { it.isEmpty() || it == "." || it == ".." }) return null + return parts.joinToString("/") { safeComponent(it) } + } + + private fun safeComponent(value: String): String { + if (value in KNOWN_COMPONENTS || KNOWN_COMPONENT_PATTERNS.any { it.matches(value) }) return value + val suffix = SAFE_SUFFIX.find(value)?.value.orEmpty().lowercase(Locale.US) + val digest = MessageDigest.getInstance("SHA-256").digest(value.toByteArray()) + .take(8).joinToString("") { "%02x".format(Locale.US, it.toInt() and 0xff) } + return "entry-$digest$suffix" + } + + private fun category(entry: String): Category { + val value = entry.lowercase(Locale.US) + if (value.startsWith("battlenet/") || value.startsWith("stores/") || value.startsWith("tools/") || + value.contains("droiddeck-esync/") || GAME_LOG.matches(value.substringAfterLast('/')) || + listOf("proton", "wine", "dxvk", "vkd3d", "battle.net", "game-debug").any(value::contains)) return Category.GAMES + if (listOf("wayland", "gamescope", "xwayland", "vulkan", "gpu", "mesa", "egl", "glx", "drm", "compositor", "frame-trace").any(value::contains)) return Category.GRAPHICS + return Category.SESSION + } + + private val GAME_LOG = Regex("steam-[0-9]+\\.(log|txt)") + private val KNOWN_COMPONENTS = setOf( + "steam", "graphics", "games", "battlenet", "client", "agent", "setup", "stores", "tools", + "droiddeck", "droiddeck-esync", "session.log", "app.log", "wayland.log", "audio.log", + "device.txt", "network.txt", "events.jsonl", "memory.csv", "capture.json", "crash.log", + "frame-trace.log", "process-trace.log", "game-lifecycle.log", "launches.log", "tools.tsv", "wanted.tsv", "prefixes.json", + "battlenet.log", "spawned.log", "flatpak-install.log", "cef_log.txt", "cef_log.previous.txt", + "console_log.txt", "webhelper_js.txt", "controller_support.txt", "systemperfmanager.txt", + ) + private val KNOWN_COMPONENT_PATTERNS = listOf( + Regex("[0-9]{4}-[0-9]{2}-[0-9]{2}-[0-9]{2,}-[a-z0-9-]{1,24}"), + Regex("steam-[0-9]+\\.(?:log|txt)"), + Regex("(?:battle\\.net-[0-9]+|battle\\.net-setup-[0-9]+|Agent-[0-9]+)\\.log"), + Regex("(?:Agent\\.[0-9]+|bna_[0-9]+)"), + Regex("stores-[0-9]{4}-[0-9]{2}-[0-9]{2}\\.log"), + Regex("entry-[0-9a-f]{16}(?:\\.[a-z0-9]{1,8})?"), + ) + private val SAFE_SUFFIX = Regex("\\.[A-Za-z0-9]{1,8}$") + private val CRITICAL_SESSION_FILES = listOf( + "session.log", "app.log", "wayland.log", "audio.log", "device.txt", "network.txt", + "events.jsonl", "memory.csv", "capture.json", "crash.log", + ) + private const val RECENT_MILLIS = 7L * 24 * 60 * 60 * 1000 + private const val TRACE_SCAN_BYTES = 16L * 1024 * 1024 + private const val LEGACY_LOG_MAX_BYTES = 8L * 1024 * 1024 + private const val MAX_BATTLENET_SCAN = 64 + private const val MAX_BATTLENET_DIRECTORIES = 64 + private const val MAX_MANIFEST_RECORDS = 512 + private const val MAX_DISCOVERY_VISITS = 4096 +} diff --git a/app/src/main/java/com/droiddeck/launcher/session/GameEnvironmentStore.kt b/app/src/main/java/com/droiddeck/launcher/session/GameEnvironmentStore.kt index 27882ebcf1..2a19f39abc 100644 --- a/app/src/main/java/com/droiddeck/launcher/session/GameEnvironmentStore.kt +++ b/app/src/main/java/com/droiddeck/launcher/session/GameEnvironmentStore.kt @@ -117,8 +117,7 @@ object GameEnvironmentStore { if (gameDxvk.length() > 0) json.put(DXVK_CONFIG_GAMES, gameDxvk) json.put( GAME_DEBUG_LOGS, - gameDebugLogsOverride ?: (SessionPrefs.logsEnabled(context) && - SessionPrefs.gameDebugLogsEnabled(context) && SessionPaths.currentSessionLogsRetained(context)), + gameDebugLogsOverride ?: SessionPrefs.gameDebugLogsEffective(context), ) write(File(LinuxRuntime.rootDir(context), GUEST_FILE), json.toString()) } diff --git a/app/src/main/java/com/droiddeck/launcher/session/SessionFiles.kt b/app/src/main/java/com/droiddeck/launcher/session/SessionFiles.kt index a947bf7e1f..ca9cafcabf 100644 --- a/app/src/main/java/com/droiddeck/launcher/session/SessionFiles.kt +++ b/app/src/main/java/com/droiddeck/launcher/session/SessionFiles.kt @@ -40,6 +40,7 @@ object SessionFiles { WinComponents.publish(context) val files = arrayOf( "usr/local/bin/droiddeck-game-env" to "usr/local/bin/droiddeck-game-env", + "usr/local/bin/droiddeck-diagnostic-inventory" to "usr/local/bin/droiddeck-diagnostic-inventory", "usr/local/bin/droiddeck-wincomponents" to "usr/local/bin/droiddeck-wincomponents", "usr/local/bin/droiddeck-msi-install" to "usr/local/bin/droiddeck-msi-install", "usr/local/bin/droiddeck-esync" to "usr/local/bin/droiddeck-esync", diff --git a/app/src/main/java/com/droiddeck/launcher/session/SessionLogShare.kt b/app/src/main/java/com/droiddeck/launcher/session/SessionLogShare.kt index 4cf737c04c..67806c4284 100644 --- a/app/src/main/java/com/droiddeck/launcher/session/SessionLogShare.kt +++ b/app/src/main/java/com/droiddeck/launcher/session/SessionLogShare.kt @@ -11,12 +11,8 @@ import androidx.compose.runtime.mutableStateOf import androidx.compose.runtime.setValue import androidx.core.content.FileProvider import com.droiddeck.launcher.R -import com.droiddeck.launcher.core.LogRedactor -import com.droiddeck.launcher.runtime.BattleNet -import com.droiddeck.launcher.runtime.LinuxRuntime import java.io.File -import java.util.zip.ZipEntry -import java.util.zip.ZipOutputStream +import java.util.ArrayList object SessionLogShare { data class Details(val sizeBytes: Long, val modifiedAt: Long) @@ -62,84 +58,30 @@ object SessionLogShare { return knownSession && folder.isDirectory && folder.deleteRecursively() } + fun prepareEnhanced(context: Context, folder: () -> File?, done: (List) -> Unit) { + if (progress != null) return + progress = 0f + Thread({ + val zips = runCatching { + folder()?.let { dir -> + EnhancedSessionLogShare.create(context, dir, onProgress = { p -> + main.post { if (progress != null) progress = p } + }) + }.orEmpty() + }.onFailure { Log.w("SessionLogShare", "could not package enhanced diagnostics", it) } + .getOrDefault(emptyList()) + main.post { progress = null; done(zips) } + }, "share-diagnostics").start() + } + fun zipFolder(context: Context, folder: File, onProgress: ((Float) -> Unit)? = null): File? { - if (!folder.isDirectory) return null - val files = folder.walkTopDown().filter { it.isFile } - .filterNot { it.parentFile?.name == "steam" && it.length() > STEAM_LOG_MAX_BYTES }.toList() - if (files.isEmpty()) return null - val out = shareDir(context).apply { deleteRecursively(); mkdirs() } - val zip = File(out, "DroidDeck-${folder.name}.zip") - LogRedactor.learnFromRuntime(LinuxRuntime.rootDir(context)) - val live = liveSteamLogs(context, folder) - val logs = LinuxRuntime.logDir(context) - val stores = recent(File(logs, STORES_DIR)) - val tools = recent(File(logs, SessionPaths.TOOLS_DIR)) - val battleNet = battleNetLogs(context) - val total = (files + live + stores + tools + battleNet.map { it.second }).sumOf { it.length() }.coerceAtLeast(1L) - var done = 0L - var shown = -1 - fun advance(f: File) { - done += f.length() - val percent = (done * 100 / total).toInt() - if (percent != shown) { shown = percent; onProgress?.invoke(percent / 100f) } - } - ZipOutputStream(zip.outputStream().buffered()).use { z -> - files.forEach { f -> addEntry(z, folder.name + "/" + f.relativeTo(folder).invariantSeparatorsPath, f); advance(f) } - live.forEach { f -> addEntry(z, folder.name + "/steam/" + f.name, f); advance(f) } - stores.forEach { f -> addEntry(z, "$STORES_DIR/" + f.name, f); advance(f) } - tools.forEach { f -> addEntry(z, SessionPaths.TOOLS_DIR + "/" + f.name, f); advance(f) } - battleNet.forEach { (name, f) -> addEntry(z, "$BATTLENET_DIR/$name", f); advance(f) } - } - return zip + return EnhancedSessionLogShare.createLegacy(context, folder, onProgress) } - private fun addEntry(z: ZipOutputStream, name: String, f: File) { - z.putNextEntry(ZipEntry(name)) - val w = z.bufferedWriter() - LogRedactor.scrubForShare(f, w) - w.flush() - z.closeEntry() - } - - private fun liveSteamLogs(context: Context, folder: File): List { - if (folder != SessionPaths.current() || File(folder, "steam").exists()) return emptyList() - val logs = File(SessionPrefs.activeSteamRoot(context), "logs") - return logs.listFiles()?.filter { it.isFile && it.length() <= STEAM_LOG_MAX_BYTES }.orEmpty() - } - - private const val STEAM_LOG_MAX_BYTES = 8L * 1024 * 1024 - const val STORES_DIR = "stores" - private const val RECENT_DAYS = 7 - private fun shareDir(context: Context): File = File(context.cacheDir, "share") - - private const val BATTLENET_DIR = "battlenet" - - private fun battleNetLogs(context: Context): List> { - val drive = File(BattleNet.prefix(context), "pfx/drive_c") - val data = File(drive, "ProgramData/Battle.net") - fun logsUnder(dir: File, prefix: String) = dir.listFiles { f -> f.isDirectory && f.name.startsWith(prefix) }.orEmpty().map { File(it, "Logs") } - return newest("droiddeck", listOf(File(LinuxRuntime.rootDir(context), "root/.cache/droiddeck/battlenet")), 2, setOf("battlenet.log", "spawned.log")) + - newest("client", listOf(File(drive, "users/steamuser/AppData/Local/Battle.net/Logs")), 6) + - newest("agent", listOf(File(data, "Agent/Logs")) + logsUnder(File(data, "Agent"), "Agent."), 10, byDir = true) + - newest("setup", logsUnder(File(data, "Setup"), ""), 3, byDir = true) - } - - private fun newest(folder: String, dirs: List, count: Int, names: Set? = null, byDir: Boolean = false): List> { - val since = System.currentTimeMillis() - RECENT_DAYS * 86_400_000L - return dirs.flatMap { dir -> - dir.listFiles { f -> f.isFile && f.name.endsWith(".log") && (names == null || f.name in names) && f.lastModified() >= since && f.length() <= STEAM_LOG_MAX_BYTES }.orEmpty().toList() - }.sortedByDescending { it.lastModified() }.take(count).map { f -> - (if (byDir) "$folder/${f.parentFile?.parentFile?.name}/${f.name}" else "$folder/${f.name}") to f - } - } - - private fun recent(dir: File): List { - val since = System.currentTimeMillis() - RECENT_DAYS * 86_400_000L - return dir.listFiles { f -> f.isFile && f.lastModified() >= since }?.sortedBy { it.name }.orEmpty() - } + internal fun shareDir(context: Context): File = File(context.cacheDir, "share") fun clear(context: Context) { shareDir(context).deleteRecursively() @@ -156,4 +98,19 @@ object SessionLogShare { send.clipData = ClipData.newRawUri(zip.name, uri) return Intent.createChooser(send, context.getString(R.string.logshare_chooser)).addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION) } + + fun shareEnhancedIntent(context: Context, zips: List): Intent { + require(zips.isNotEmpty()) + val uris = ArrayList(zips.map { FileProvider.getUriForFile(context, context.packageName + ".logs", it) }) + val send = Intent(Intent.ACTION_SEND_MULTIPLE) + .setType("application/zip") + .putParcelableArrayListExtra(Intent.EXTRA_STREAM, uris) + .putExtra(Intent.EXTRA_SUBJECT, zips.first().name.substringBeforeLast('-')) + .addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION) + send.clipData = ClipData.newUri(context.contentResolver, zips.first().name, uris.first()).also { clip -> + for (i in 1 until uris.size) clip.addItem(ClipData.Item(uris[i])) + } + return Intent.createChooser(send, context.getString(R.string.logshare_chooser)) + .addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION) + } } diff --git a/app/src/main/java/com/droiddeck/launcher/session/SessionPaths.kt b/app/src/main/java/com/droiddeck/launcher/session/SessionPaths.kt index 6f335f231c..524271d4a9 100644 --- a/app/src/main/java/com/droiddeck/launcher/session/SessionPaths.kt +++ b/app/src/main/java/com/droiddeck/launcher/session/SessionPaths.kt @@ -26,7 +26,8 @@ object SessionPaths { @Synchronized fun beginOrCurrent(context: Context, label: String? = null): File { dir?.let { if (it.isDirectory) return it } - val parent = if (SessionPrefs.logsEnabled(context)) SessionFiles.logDirectory(context) + val enhanced = EnhancedDiagnostics.isArmed(context) + val parent = if (SessionPrefs.logsEnabled(context) || enhanced) SessionFiles.logDirectory(context) else File(context.cacheDir, "session-logs") val day = SimpleDateFormat("yyyy-MM-dd", Locale.US).format(Date()) val last = parent.listFiles()?.mapNotNull { f -> @@ -36,9 +37,13 @@ object SessionPaths { var number = last + 1 var made = File(parent, "$day-${"%02d".format(Locale.US, number)}-$what") while (made.exists()) made = File(parent, "$day-${"%02d".format(Locale.US, ++number)}-$what") + EnhancedDiagnostics.clearRecordFor(context, made) if (!made.isDirectory && !made.mkdirs()) Log.e(TAG, "could not create $made") dir = made - Log.i(TAG, "session logs: $made" + if (SessionPrefs.logsEnabled(context)) "" else " (logs off: discarded at the end)") + if (enhanced && !EnhancedDiagnostics.consumeInto(context, made)) { + Log.e(TAG, "could not activate enhanced diagnostics for $made") + } + Log.i(TAG, "session logs: $made" + if (parent == SessionFiles.logDirectory(context)) "" else " (logs off: discarded at the end)") return made } diff --git a/app/src/main/java/com/droiddeck/launcher/session/SessionPrefs.kt b/app/src/main/java/com/droiddeck/launcher/session/SessionPrefs.kt index 48bdeffdef..2e7f3b6c54 100644 --- a/app/src/main/java/com/droiddeck/launcher/session/SessionPrefs.kt +++ b/app/src/main/java/com/droiddeck/launcher/session/SessionPrefs.kt @@ -824,7 +824,7 @@ object SessionPrefs { key = "logs", oldValue = logsEnabled(context), newValue = on, - newEffective = on && gameDebugLogsEnabled(context) && SessionPaths.currentSessionLogsRetained(context), + newEffective = gameDebugLogsEffective(context, on, gameDebugLogsEnabled(context)), ) } @@ -837,7 +837,7 @@ object SessionPrefs { key = "gameDebugLogsEnabled", oldValue = gameDebugLogsEnabled(context), newValue = on, - newEffective = logsEnabled(context) && on && SessionPaths.currentSessionLogsRetained(context), + newEffective = gameDebugLogsEffective(context, logsEnabled(context), on), ) } @@ -850,8 +850,7 @@ object SessionPrefs { ): Boolean { if (oldValue == newValue) return true val saved = prefs(context) - val oldEffective = logsEnabled(context) && gameDebugLogsEnabled(context) && - SessionPaths.currentSessionLogsRetained(context) + val oldEffective = gameDebugLogsEffective(context) fun publish(value: Boolean) = GameEnvironmentStore.publish(context, gameDebugLogsOverride = value) if (oldEffective == newEffective) { if (saved.edit().putBoolean(key, newValue).commit()) return true @@ -887,6 +886,13 @@ object SessionPrefs { } } + internal fun gameDebugLogsEffective( + context: Context, + logs: Boolean = logsEnabled(context), + gameLogs: Boolean = gameDebugLogsEnabled(context), + ): Boolean = EnhancedDiagnostics.isCurrentSessionActive(context) || + (logs && gameLogs && SessionPaths.currentSessionLogsRetained(context)) + fun battleNetNoSteamSet(context: Context): Boolean = prefs(context).getBoolean("battleNetNoSteamSet", false) fun setBattleNetNoSteamSet(context: Context) { prefs(context).edit().putBoolean("battleNetNoSteamSet", true).apply() } diff --git a/app/src/main/java/com/droiddeck/launcher/session/SessionService.kt b/app/src/main/java/com/droiddeck/launcher/session/SessionService.kt index 12c848d1cb..29234f1d38 100644 --- a/app/src/main/java/com/droiddeck/launcher/session/SessionService.kt +++ b/app/src/main/java/com/droiddeck/launcher/session/SessionService.kt @@ -540,6 +540,7 @@ class SessionService : Service() { guest.add("BL_REFRESH=" + Math.round(SessionState.refreshHz)) guest.add("BL_LOG=" + sessionLog.path) guest.add("BL_DEBUG_DIR=" + sessionDir.path) + if (EnhancedDiagnostics.isActive(this, sessionDir)) guest.add("DROIDDECK_ENHANCED_DIAGNOSTICS=1") val fakeInputDir = File(sessionRoot, "dev/input").apply { mkdirs() } val controllersOn = !File(Environment.getExternalStorageDirectory(), NO_PAD_SWITCH).exists() @@ -768,6 +769,7 @@ class SessionService : Service() { SessionState.sessionId = sessionDir.name SessionState.eventsFile = File(sessionDir, "events.jsonl") SessionEvents.record("session.logs_ready", mapOf("logDir" to sessionDir.path)) + if (EnhancedDiagnostics.isActive(this, sessionDir)) SessionEvents.record("diagnostics.enhanced", mapOf("schema" to 1)) DeviceReport.write(this, File(sessionDir, "device.txt"), SessionState.mode) NetworkReport.write(this, File(sessionDir, "network.txt")) SessionLogCapture.start(File(sessionDir, "app.log")) diff --git a/app/src/main/java/com/droiddeck/launcher/session/SettingsReset.kt b/app/src/main/java/com/droiddeck/launcher/session/SettingsReset.kt index c47bdd7986..f315c1e1a6 100644 --- a/app/src/main/java/com/droiddeck/launcher/session/SettingsReset.kt +++ b/app/src/main/java/com/droiddeck/launcher/session/SettingsReset.kt @@ -22,7 +22,7 @@ object SettingsReset { "tuSysmem", "glThread", "noGlError", "zinkLazy", "mangoapp", "gpuClockPin", "gamescopeRealtime", "ramCapMb", "vramCapMb", "zramClient", "directAudio", "mic", "wifiDiscovery", "clientCpusOverride", "clientCpus", "gameCpus", "noXalia", "fastSync", "fsyncFirst", "syncFallback", "prootNoSeccomp", "prootFastPath", "cursorComposite", - "guestHostname", "fexPreset", "forceSsbs", "logs", "gameDebugLogsEnabled", "storageDiagnostics", + "guestHostname", "fexPreset", "forceSsbs", "logs", "gameDebugLogsEnabled", "enhancedDiagnosticsNext", "storageDiagnostics", "upscaler", "upscaleSharpness", "screenEffects", "textureAnisotropy", "textureLodBias", "steamDownloadsInBackground", "steam_offline", "bootMovie", "bootMovieSound", "bootMovieVolume", "bootMovieSeconds", "bootMovieApplyNext", "bootMovieSteamSeen", diff --git a/app/src/main/java/com/droiddeck/launcher/ui/FrontEndScreen.kt b/app/src/main/java/com/droiddeck/launcher/ui/FrontEndScreen.kt index 44f629b348..5881ad715d 100644 --- a/app/src/main/java/com/droiddeck/launcher/ui/FrontEndScreen.kt +++ b/app/src/main/java/com/droiddeck/launcher/ui/FrontEndScreen.kt @@ -102,6 +102,7 @@ class FrontEndState( val frameGenLabel: String, val romsDir: String?, val logsEnabled: Boolean, + val enhancedDiagnosticsArmed: Boolean = false, val gameDebugLogsEnabled: Boolean = false, val gameDebugLogsNeedsRestart: Boolean = false, val vacDiagnostics: Boolean = false, @@ -227,6 +228,7 @@ class FrontEndActions( val onFiles: () -> Unit, val onBrowseFiles: (File) -> Unit = {}, val onLogs: () -> Unit, + val onEnhancedDiagnostics: () -> Unit = {}, val onGameDebugLogs: () -> Unit = {}, val onVacDiagnostics: () -> Unit = {}, val onAgentCommands: () -> Unit = {}, diff --git a/app/src/main/java/com/droiddeck/launcher/ui/FrontEndSetup.kt b/app/src/main/java/com/droiddeck/launcher/ui/FrontEndSetup.kt index 795b1b1c1c..830b68ef35 100644 --- a/app/src/main/java/com/droiddeck/launcher/ui/FrontEndSetup.kt +++ b/app/src/main/java/com/droiddeck/launcher/ui/FrontEndSetup.kt @@ -546,6 +546,10 @@ internal fun SetupPanel( 5 -> { SettingsGroup(stringResource(R.string.setup_tab_diagnostics)) { ToggleRow(host, "logs", stringResource(R.string.setup_logs), stringResource(R.string.setup_logs_hint), s.logsEnabled) { a.onLogs() } + ToggleRow( + host, "enhanced-diagnostics", stringResource(R.string.setup_enhanced_diagnostics), + stringResource(R.string.setup_enhanced_diagnostics_hint), s.enhancedDiagnosticsArmed, + ) { a.onEnhancedDiagnostics() } ToggleRow( host, "game-debug-logs", stringResource(R.string.setup_game_debug_logs), stringResource(if (s.gameDebugLogsNeedsRestart) R.string.setup_game_debug_logs_restart else R.string.setup_game_debug_logs_hint), diff --git a/app/src/main/res/values/strings.xml b/app/src/main/res/values/strings.xml index c038b1841d..56c27ae794 100644 --- a/app/src/main/res/values/strings.xml +++ b/app/src/main/res/values/strings.xml @@ -915,6 +915,13 @@ Session Session logs Saved after each session + Enhanced diagnostics for next session + Captures detailed logs for one session. May reduce performance and use more storage. Turns itself off when the session starts; review logs before sharing. + Share diagnostic bundles + Session and device + Graphics + Games and compatibility + All bundles Game debug logs Include Proton, Wine and graphics diagnostics on the next game launch. Can reduce performance and use more storage. Restart this session to save game debug logs diff --git a/app/src/test/java/com/droiddeck/launcher/core/LogRedactorTest.kt b/app/src/test/java/com/droiddeck/launcher/core/LogRedactorTest.kt index b93c439bf2..4a76243bbd 100644 --- a/app/src/test/java/com/droiddeck/launcher/core/LogRedactorTest.kt +++ b/app/src/test/java/com/droiddeck/launcher/core/LogRedactorTest.kt @@ -316,6 +316,60 @@ class LogRedactorTest { } } + @Test fun oversizedAccountMetadataIsRejectedWithoutForgettingKnownNames() { + val users = tmp.newFile("known-loginusers.vdf") + val oversized = tmp.newFile("oversized-loginusers.vdf") + users.writeText("\"AccountName\" \"previous_player\"") + java.io.RandomAccessFile(oversized, "rw").use { + it.setLength(LogRedactor.MAX_LEARN_INPUT_BYTES.toLong() + 1) + } + try { + assertTrue(LogRedactor.learnAccounts(users)) + assertFalse(LogRedactor.learnAccounts(oversized)) + assertEquals("", LogRedactor.redact("previous_player")) + } finally { + LogRedactor.learnAccounts() + } + } + + @Test fun repeatedIncompleteAccountLearningKeepsOnlyABoundedRecentSet() { + val users = tmp.newFile("changing-loginusers.vdf") + val oversized = tmp.newFile("unreadable-loginusers.vdf") + java.io.RandomAccessFile(oversized, "rw").use { + it.setLength(LogRedactor.MAX_LEARN_INPUT_BYTES.toLong() + 1) + } + try { + LogRedactor.learnAccounts() + repeat(3) { batch -> + users.writeText((0 until 1024).joinToString("\n") { + "\"AccountName\" \"round${batch}player${it.toString().padStart(4, '0')}\"" + }) + assertFalse(LogRedactor.learnAccounts(users, oversized)) + } + assertEquals("", LogRedactor.redact("round2player0000")) + assertEquals("", LogRedactor.redact("round1player0000")) + assertEquals("round0player0000", LogRedactor.redact("round0player0000")) + } finally { + LogRedactor.learnAccounts() + } + } + + @Test fun oversizedAddressMetadataIsRejectedWithoutForgettingKnownAddresses() { + val link = tmp.newFile("known-network") + val oversized = tmp.newFile("oversized-network") + link.writeText("addr 203.0.113.40 24\n") + java.io.RandomAccessFile(oversized, "rw").use { + it.setLength(LogRedactor.MAX_LEARN_INPUT_BYTES.toLong() + 1) + } + try { + assertTrue(LogRedactor.learnOwnAddresses(link)) + assertFalse(LogRedactor.learnOwnAddresses(oversized)) + assertEquals("", LogRedactor.redact("203.0.113.40")) + } finally { + LogRedactor.learnOwnAddresses(tmp.root.resolve("missing-network")) + } + } + @Test fun manyLearnedAddressesKeepOtherAddresses() { val link = tmp.newFile("droiddeck-net") link.writeText((1..40).joinToString("\n") { "addr 203.0.113.$it 24" }) diff --git a/app/src/test/java/com/droiddeck/launcher/session/EnhancedDiagnosticsTest.kt b/app/src/test/java/com/droiddeck/launcher/session/EnhancedDiagnosticsTest.kt new file mode 100644 index 0000000000..f4a85bb8fe --- /dev/null +++ b/app/src/test/java/com/droiddeck/launcher/session/EnhancedDiagnosticsTest.kt @@ -0,0 +1,140 @@ +package com.droiddeck.launcher.session + +import android.content.Context +import com.droiddeck.launcher.runtime.LinuxRuntime +import org.json.JSONObject +import org.junit.After +import org.junit.Assert.assertEquals +import org.junit.Assert.assertFalse +import org.junit.Assert.assertNull +import org.junit.Assert.assertTrue +import org.junit.Before +import org.junit.Test +import org.junit.runner.RunWith +import org.robolectric.RobolectricTestRunner +import org.robolectric.RuntimeEnvironment +import org.robolectric.annotation.Config +import java.io.File + +@RunWith(RobolectricTestRunner::class) +@Config(sdk = [28], manifest = Config.NONE) +class EnhancedDiagnosticsTest { + private lateinit var context: Context + private lateinit var guest: File + + @Before fun setUp() { + context = RuntimeEnvironment.getApplication() + SessionPaths.take()?.let { SessionPaths.release(context, it) } + context.getSharedPreferences("session", Context.MODE_PRIVATE).edit() + .remove("logs") + .remove("gameDebugLogsEnabled") + .remove("enhancedDiagnosticsNext") + .remove("enhancedDiagnosticsActiveSessions") + .commit() + guest = File(LinuxRuntime.rootDir(context), "root/.config/droiddeck/game-environment.json") + } + + @After fun tearDown() { + SessionPaths.take()?.let { folder -> + SessionPaths.release(context, folder) + folder.deleteRecursively() + } + context.getSharedPreferences("session", Context.MODE_PRIVATE).edit() + .remove("logs") + .remove("gameDebugLogsEnabled") + .remove("enhancedDiagnosticsNext") + .remove("enhancedDiagnosticsActiveSessions") + .commit() + GameEnvironmentStore.publish(context) + } + + @Test fun armedSessionIsRetainedAndConsumesTheOneShotPreference() { + context.getSharedPreferences("session", Context.MODE_PRIVATE).edit().putBoolean("logs", false).commit() + assertTrue(EnhancedDiagnostics.setArmed(context, true)) + + val folder = SessionPaths.beginOrCurrent(context, "enhanced-test") + + assertEquals(SessionFiles.logDirectory(context), folder.parentFile) + assertFalse(EnhancedDiagnostics.isArmed(context)) + assertTrue(EnhancedDiagnostics.isActive(context, folder)) + val manifest = JSONObject(File(folder, EnhancedDiagnostics.MANIFEST_FILE).readText()) + assertEquals(1, manifest.getInt("schema")) + assertEquals("enhanced", manifest.getString("profile")) + assertEquals(folder.name, manifest.getString("sessionId")) + assertTrue(manifest.getBoolean("exportBundlesBounded")) + assertFalse(manifest.getBoolean("rawCaptureByteBounded")) + } + + @Test fun activeProfileForcesGameDiagnosticsWithoutChangingUserPreferences() { + context.getSharedPreferences("session", Context.MODE_PRIVATE).edit() + .putBoolean("logs", false) + .putBoolean("gameDebugLogsEnabled", false) + .commit() + assertTrue(EnhancedDiagnostics.setArmed(context, true)) + SessionPaths.beginOrCurrent(context, "enhanced-game-logs") + + GameEnvironmentStore.publish(context) + + assertTrue(JSONObject(guest.readText()).getBoolean(GameEnvironmentStore.GAME_DEBUG_LOGS)) + assertFalse(SessionPrefs.logsEnabled(context)) + assertFalse(SessionPrefs.gameDebugLogsEnabled(context)) + } + + @Test fun cancellingTheOneShotLeavesOrdinaryLogRetentionUnchanged() { + context.getSharedPreferences("session", Context.MODE_PRIVATE).edit().putBoolean("logs", false).commit() + assertTrue(EnhancedDiagnostics.setArmed(context, true)) + assertTrue(EnhancedDiagnostics.setArmed(context, false)) + + val folder = SessionPaths.beginOrCurrent(context, "ordinary-test") + + assertEquals(File(context.cacheDir, "session-logs"), folder.parentFile) + assertFalse(EnhancedDiagnostics.isActive(context, folder)) + } + + @Test fun guestCannotForgeEnhancedDiagnosticsByWritingAMarker() { + val folder = SessionPaths.beginOrCurrent(context, "forged-marker") + File(folder, EnhancedDiagnostics.MANIFEST_FILE).writeText( + """{"schema":1,"profile":"enhanced"}""", + ) + + assertFalse(EnhancedDiagnostics.isActive(context, folder)) + assertNull(EnhancedDiagnostics.manifest(context, folder)) + } + + @Test fun trustedStateSurvivesGuestMarkerDeletionAndSessionRecovery() { + assertTrue(EnhancedDiagnostics.setArmed(context, true)) + val folder = SessionPaths.beginOrCurrent(context, "deleted-marker") + assertTrue(File(folder, EnhancedDiagnostics.MANIFEST_FILE).delete()) + + assertTrue(EnhancedDiagnostics.isActive(context, File(folder.path))) + assertEquals(folder.name, EnhancedDiagnostics.manifest(context, folder)?.getString("sessionId")) + assertEquals(folder, SessionPaths.take()) + assertTrue(EnhancedDiagnostics.isActive(context, folder)) + } + + @Test fun informationalMarkerFailureDoesNotRearmTheNextSession() { + val parent = SessionFiles.logDirectory(context).apply { mkdirs() } + val folder = File(parent, "2026-11-04-99-marker-failure").apply { mkdirs() } + File(folder, EnhancedDiagnostics.MANIFEST_FILE).mkdirs() + assertTrue(EnhancedDiagnostics.setArmed(context, true)) + + assertTrue(EnhancedDiagnostics.consumeInto(context, folder)) + + assertTrue(EnhancedDiagnostics.isActive(context, folder)) + assertFalse(EnhancedDiagnostics.isArmed(context)) + folder.deleteRecursively() + } + + @Test fun aReusedSessionPathDoesNotInheritTrustedState() { + assertTrue(EnhancedDiagnostics.setArmed(context, true)) + val original = SessionPaths.beginOrCurrent(context, "reused-path") + assertTrue(EnhancedDiagnostics.isActive(context, original)) + assertEquals(original, SessionPaths.take()) + original.deleteRecursively() + + val replacement = SessionPaths.beginOrCurrent(context, "reused-path") + + assertEquals(original.path, replacement.path) + assertFalse(EnhancedDiagnostics.isActive(context, replacement)) + } +} diff --git a/app/src/test/java/com/droiddeck/launcher/session/EnhancedSessionLogShareTest.kt b/app/src/test/java/com/droiddeck/launcher/session/EnhancedSessionLogShareTest.kt new file mode 100644 index 0000000000..73dd3f2132 --- /dev/null +++ b/app/src/test/java/com/droiddeck/launcher/session/EnhancedSessionLogShareTest.kt @@ -0,0 +1,331 @@ +package com.droiddeck.launcher.session + +import android.content.Intent +import org.json.JSONObject +import org.junit.Assert.assertEquals +import org.junit.Assert.assertFalse +import org.junit.Assert.assertTrue +import org.junit.Assume.assumeFalse +import org.junit.Rule +import org.junit.Test +import org.junit.rules.TemporaryFolder +import org.junit.runner.RunWith +import org.robolectric.RobolectricTestRunner +import org.robolectric.RuntimeEnvironment +import org.robolectric.annotation.Config +import java.io.RandomAccessFile +import java.nio.file.Files +import java.util.zip.ZipFile + +@RunWith(RobolectricTestRunner::class) +@Config(sdk = [33]) +class EnhancedSessionLogShareTest { + @get:Rule val tmp = TemporaryFolder() + private val app get() = RuntimeEnvironment.getApplication() + + @Test fun diagnosticsAreSplitIntoManifestedArchivesWithOneSessionIdentity() { + val session = tmp.newFolder("2026-11-04-01-steam") + session.resolve("session.log").writeText("startup ok\n") + session.resolve("wayland.log").writeText("frame import ok\n") + session.resolve("steam-42.log").writeText("dxvk: present ok\n") + + val zips = EnhancedSessionLogShare.create(app, session) + + assertEquals( + setOf("session", "graphics", "games"), + zips.map { it.nameWithoutExtension.substringAfterLast('-') }.toSet(), + ) + val expected = mapOf( + "session" to "${session.name}/session.log", + "graphics" to "${session.name}/wayland.log", + "games" to "${session.name}/steam-42.log", + ) + zips.forEach { zip -> + val category = zip.nameWithoutExtension.substringAfterLast('-') + ZipFile(zip).use { archive -> + assertTrue(archive.getEntry(expected.getValue(category)) != null) + val manifest = JSONObject(archive.getInputStream(archive.getEntry("diagnostics-manifest.json")) + .bufferedReader().readText()) + assertEquals(1, manifest.getInt("schema")) + assertEquals(session.name, manifest.getString("sessionId")) + assertEquals(category, manifest.getString("category")) + assertEquals("captured", manifest.getJSONArray("entries").getJSONObject(0).getString("status")) + } + } + SessionLogShare.clear(app) + } + + @Test fun oversizedFilesKeepBoundedBeginningAndTailAndDeclareTruncation() { + val session = tmp.newFolder("2026-11-04-02-game") + session.resolve("steam-7.log").writeText("begin\n" + "middle\n".repeat(100) + "tail\n") + val limits = EnhancedShareLimits(maxFilesPerArchive = 8, maxBytesPerFile = 96, maxBytesTotal = 512) + + val games = EnhancedSessionLogShare.create(app, session, limits = limits) + .single { it.name.endsWith("-games.zip") } + + ZipFile(games).use { archive -> + val text = archive.getInputStream(archive.getEntry("${session.name}/steam-7.log")).bufferedReader().readText() + assertTrue(text.startsWith("begin")) + assertTrue(text.contains("diagnostic file truncated")) + assertTrue(text.endsWith("tail\n")) + val manifest = JSONObject(archive.getInputStream(archive.getEntry("diagnostics-manifest.json")) + .bufferedReader().readText()) + assertEquals("truncated", manifest.getJSONArray("entries").getJSONObject(0).getString("status")) + assertTrue(manifest.getJSONArray("entries").getJSONObject(0).getLong("capturedBytes") <= 96) + } + SessionLogShare.clear(app) + } + + @Test fun symbolicLinksAreNotReadAndTheirOmissionIsRecorded() { + assumeFalse(System.getProperty("os.name").startsWith("Windows")) + val session = tmp.newFolder("2026-11-04-03-steam") + session.resolve("session.log").writeText("safe\n") + val outside = tmp.newFile("private.log").apply { writeText("do-not-share\n") } + val link = session.toPath().resolve("wayland.log") + runCatching { Files.createSymbolicLink(link, outside.toPath()) }.getOrElse { return } + + val graphics = EnhancedSessionLogShare.create(app, session).single { it.name.endsWith("-graphics.zip") } + + ZipFile(graphics).use { archive -> + assertFalse(archive.entries().toList().any { it.name.endsWith("wayland.log") }) + val manifest = JSONObject(archive.getInputStream(archive.getEntry("diagnostics-manifest.json")) + .bufferedReader().readText()) + val entries = manifest.getJSONArray("entries") + assertTrue((0 until entries.length()).map { entries.getJSONObject(it) } + .any { it.optString("reason") == "unsafe-or-unavailable-source" }) + } + SessionLogShare.clear(app) + } + + @Test fun enhancedShareUsesOneMultipleAttachmentIntent() { + val session = tmp.newFolder("2026-11-04-04-steam") + session.resolve("session.log").writeText("safe\n") + val zips = EnhancedSessionLogShare.create(app, session) + + val chooser = SessionLogShare.shareEnhancedIntent(app, zips) + val send = chooser.getParcelableExtra(Intent.EXTRA_INTENT)!! + + assertEquals(Intent.ACTION_SEND_MULTIPLE, send.action) + assertEquals("application/zip", send.type) + assertEquals(3, send.getParcelableArrayListExtra(Intent.EXTRA_STREAM)!!.size) + assertEquals(3, send.clipData!!.itemCount) + SessionLogShare.clear(app) + } + + @Test fun graphicsArchiveIncludesOnlyBoundedFrameTraceSummariesFromTheSessionLog() { + val session = tmp.newFolder("2026-11-04-05-steam") + session.resolve("session.log").writeText( + "normal startup line\n" + + "DROIDDECK_FRAME_TRACE xdamage=4 commits=2\n" + + "unrelated account=test-user\n" + + "DROIDDECK_FRAME_TRACE xdamage=9 commits=8\n" + + "DROIDDECK_PROCESS_TRACE pid=42 gpuLibs=libvulkan.so\n", + ) + + val graphics = EnhancedSessionLogShare.create(app, session).single { it.name.endsWith("-graphics.zip") } + + ZipFile(graphics).use { archive -> + val trace = archive.getInputStream(archive.getEntry("${session.name}/graphics/frame-trace.log")) + .bufferedReader().readText() + assertEquals( + "DROIDDECK_FRAME_TRACE xdamage=4 commits=2\n" + + "DROIDDECK_FRAME_TRACE xdamage=9 commits=8\n", + trace, + ) + assertFalse(trace.contains("normal startup")) + assertFalse(trace.contains("test-user")) + val process = archive.getInputStream(archive.getEntry("${session.name}/graphics/process-trace.log")) + .bufferedReader().readText() + assertEquals("DROIDDECK_PROCESS_TRACE pid=42 gpuLibs=libvulkan.so\n", process) + } + SessionLogShare.clear(app) + } + + @Test fun truncationNeverSharesASecretWhoseLabelWasCutOffAtTheBoundary() { + val session = tmp.newFolder("2026-11-04-06-game") + val secret = "abcdef1234567890" + session.resolve("steam-8.log").writeText( + "padding-refresh_token=$secret" + "x".repeat(512) + "\nvisible tail\n", + ) + val limits = EnhancedShareLimits(maxFilesPerArchive = 8, maxBytesPerFile = 128, maxBytesTotal = 512) + + val games = EnhancedSessionLogShare.create(app, session, limits = limits) + .single { it.name.endsWith("-games.zip") } + + val shared = ZipFile(games).use { archive -> + archive.getInputStream(archive.getEntry("${session.name}/steam-8.log")).bufferedReader().readText() + } + assertFalse(shared.contains(secret)) + assertTrue(shared.contains("diagnostic file truncated")) + assertTrue(shared.endsWith("visible tail\n")) + SessionLogShare.clear(app) + } + + @Test fun discoveryStopsAtItsBoundAndDeclaresTheTruncatedInventory() { + val session = tmp.newFolder("2026-11-04-07-steam") + repeat(20) { session.resolve("log-$it.txt").writeText("line $it\n") } + val limits = EnhancedShareLimits( + maxFilesPerArchive = 8, + maxDiscoveredFiles = 2, + maxBytesPerFile = 1024, + maxBytesTotal = 4096, + ) + + val zips = EnhancedSessionLogShare.create(app, session, limits = limits) + + val captured = zips.sumOf { zip -> + ZipFile(zip).use { archive -> archive.entries().toList().count { it.name != "diagnostics-manifest.json" } } + } + assertTrue(captured <= 2) + zips.forEach { zip -> + ZipFile(zip).use { archive -> + val manifest = JSONObject(archive.getInputStream(archive.getEntry("diagnostics-manifest.json")) + .bufferedReader().readText()) + val entries = manifest.getJSONArray("entries") + assertTrue((0 until entries.length()).map { entries.getJSONObject(it) } + .any { it.optString("origin") == "discovery" && it.optString("status") == "truncated" }) + } + } + SessionLogShare.clear(app) + } + + @Test fun aGuestForgedActivationMarkerIsNeverExportedAsTrustedMetadata() { + val session = tmp.newFolder("2026-11-04-08-steam") + session.resolve("session.log").writeText("safe\n") + session.resolve(EnhancedDiagnostics.MANIFEST_FILE).writeText("{\"profile\":\"forged\"}\n") + + val zips = EnhancedSessionLogShare.create(app, session) + + zips.forEach { zip -> + ZipFile(zip).use { archive -> + assertFalse(archive.entries().toList().any { it.name.endsWith(EnhancedDiagnostics.MANIFEST_FILE) }) + } + } + SessionLogShare.clear(app) + } + + @Test fun hardLinksAreRejectedInsteadOfFollowingASecondNameToItsContent() { + assumeFalse(System.getProperty("os.name").startsWith("Windows")) + val session = tmp.newFolder("2026-11-04-09-steam") + session.resolve("session.log").writeText("safe\n") + val outside = tmp.newFile("outside-hardlink.log").apply { writeText("private hard-link content\n") } + runCatching { Files.createLink(session.toPath().resolve("wayland.log"), outside.toPath()) }.getOrElse { return } + + val graphics = EnhancedSessionLogShare.create(app, session).single { it.name.endsWith("-graphics.zip") } + + ZipFile(graphics).use { archive -> + assertFalse(archive.entries().toList().any { it.name.endsWith("wayland.log") }) + val all = archive.entries().toList().joinToString("\n") { entry -> + archive.getInputStream(entry).bufferedReader().readText() + } + assertFalse(all.contains("private hard-link content")) + } + SessionLogShare.clear(app) + } + + @Test fun guestControlledAndControlCharacterNamesNeverEnterTheArchiveOrManifest() { + val session = tmp.newFolder("2026-11-04-10-steam") + session.resolve("private-window-title.log").writeText("safe diagnostic\n") + session.resolve("wayland\nsecret.log").writeText("must not be named\n") + + val sessionZip = EnhancedSessionLogShare.create(app, session).single { it.name.endsWith("-session.zip") } + + ZipFile(sessionZip).use { archive -> + val names = archive.entries().toList().map { it.name } + assertTrue(names.any { it.contains("/entry-") && it.endsWith(".log") }) + assertFalse(names.any { it.contains("private-window-title") || it.contains('\n') }) + val manifest = archive.getInputStream(archive.getEntry("diagnostics-manifest.json")).bufferedReader().readText() + assertFalse(manifest.contains("private-window-title")) + assertFalse(manifest.contains("wayland\\nsecret")) + } + SessionLogShare.clear(app) + } + + @Test fun oneCategoryCannotConsumeTheOtherCategoriesByteReservations() { + val session = tmp.newFolder("2026-11-04-11-steam") + session.resolve("session.log").writeText("session\n".repeat(100)) + session.resolve("wayland.log").writeText("graphics\n".repeat(100)) + session.resolve("steam-11.log").writeText("game\n".repeat(100)) + val limits = EnhancedShareLimits(maxBytesPerFile = 1024, maxBytesTotal = 300) + + val zips = EnhancedSessionLogShare.create(app, session, limits = limits) + + zips.forEach { zip -> + ZipFile(zip).use { archive -> + assertTrue(archive.entries().toList().any { it.name != "diagnostics-manifest.json" }) + } + } + SessionLogShare.clear(app) + } + + @Test fun filteredTraceScanFindsLateSummariesAndMarksThePartialSource() { + val session = tmp.newFolder("2026-11-04-12-steam") + val source = session.resolve("session.log") + RandomAccessFile(source, "rw").use { file -> + file.setLength(17L * 1024 * 1024) + file.seek(file.length() - 80) + file.write("\nDROIDDECK_PROCESS_TRACE pid=99 gpuLibs=libGLES.so\n".toByteArray()) + } + + val graphics = EnhancedSessionLogShare.create(app, session).single { it.name.endsWith("-graphics.zip") } + + ZipFile(graphics).use { archive -> + val trace = archive.getInputStream(archive.getEntry("${session.name}/graphics/process-trace.log")) + .bufferedReader().readText() + assertTrue(trace.contains("pid=99")) + val manifest = JSONObject(archive.getInputStream(archive.getEntry("diagnostics-manifest.json")) + .bufferedReader().readText()) + val entries = manifest.getJSONArray("entries") + assertTrue((0 until entries.length()).map { entries.getJSONObject(it) }.any { + it.optString("origin") == "guest-process-trace" && it.optString("status") == "truncated" + }) + } + SessionLogShare.clear(app) + } + + @Test fun diagnosticLookingGuestNamesCannotExposeEmbeddedSecrets() { + val session = tmp.newFolder("2026-11-04-13-game") + val tokenName = "dxvk-refresh_token_abcdef123456.log" + val accountName = "battle.net-secretvalue.log" + session.resolve(tokenName).writeText("dxvk diagnostic\n") + session.resolve(accountName).writeText("battle net diagnostic\n") + + val games = EnhancedSessionLogShare.create(app, session).single { it.name.endsWith("-games.zip") } + + ZipFile(games).use { archive -> + val names = archive.entries().toList().map { it.name } + assertFalse(names.any { it.contains("refresh_token") || it.contains("secretvalue") }) + assertTrue(names.count { it.substringAfterLast('/').startsWith("entry-") } >= 2) + val manifest = archive.getInputStream(archive.getEntry("diagnostics-manifest.json")).bufferedReader().readText() + assertFalse(manifest.contains("refresh_token")) + assertFalse(manifest.contains("secretvalue")) + } + SessionLogShare.clear(app) + } + + @Test fun gamesArchiveIncludesOnlyGameLifecycleSummariesFromTheSessionLog() { + val session = tmp.newFolder("2026-11-04-14-game") + session.resolve("session.log").writeText( + "DROIDDECK_DIAGNOSTICS event=game_start appId=42 pid=123\n" + + "unrelated launch detail\n" + + "DROIDDECK_DIAGNOSTICS event=game_exit appId=42 status=139\n", + ) + + val games = EnhancedSessionLogShare.create(app, session).single { it.name.endsWith("-games.zip") } + + ZipFile(games).use { archive -> + val lifecycle = archive.getInputStream(archive.getEntry("${session.name}/games/game-lifecycle.log")) + .bufferedReader().readText() + assertEquals( + "DROIDDECK_DIAGNOSTICS event=game_start appId=42 pid=123\n" + + "DROIDDECK_DIAGNOSTICS event=game_exit appId=42 status=139\n", + lifecycle, + ) + assertFalse(lifecycle.contains("unrelated launch detail")) + val manifest = JSONObject(archive.getInputStream(archive.getEntry("diagnostics-manifest.json")) + .bufferedReader().readText()) + assertTrue(manifest.toString().contains("guest-game-lifecycle")) + } + SessionLogShare.clear(app) + } +} diff --git a/app/src/test/java/com/droiddeck/launcher/session/SessionLogShareTest.kt b/app/src/test/java/com/droiddeck/launcher/session/SessionLogShareTest.kt index 2e00e83c69..678ae876fd 100644 --- a/app/src/test/java/com/droiddeck/launcher/session/SessionLogShareTest.kt +++ b/app/src/test/java/com/droiddeck/launcher/session/SessionLogShareTest.kt @@ -86,8 +86,9 @@ class SessionLogShareTest { File(folder, "events.jsonl").writeText("$secret\n") val out = zip(folder) - for (name in listOf("app.log", "session.log", "steam/deep/nested.txt", ".hidden.txt", "events.jsonl")) + for (name in listOf("app.log", "session.log", "events.jsonl")) assertFalse(name, out.getValue(name).contains(leaked)) + assertTrue(out.values.none { it.contains(leaked) }) } @Test fun aRecordUnderOtherRedactorRulesVouchesForNothing() { @@ -187,7 +188,7 @@ class SessionLogShareTest { assertFalse(File(folder, ".scrubbed-r${LogRedactor.RULES_VERSION}").exists()) } - @Test fun steamLogsPastTheSizeLimitStayOut() { + @Test fun steamLogsPastTheSizeLimitAreBoundedAndDeclared() { val folder = tmp.newFolder("2026-10-06-07-steam") File(folder, "session.log").writeText("ok\n") File(folder, "steam").mkdirs() @@ -196,9 +197,11 @@ class SessionLogShareTest { val line = ByteArray(1024) { 'x'.code.toByte() }.also { it[it.size - 1] = '\n'.code.toByte() } repeat(9 * 1024) { out.write(line) } } - val names = zip(folder).keys - assertTrue("steam/console_log.txt" in names) - assertFalse("steam/cef_log.previous.txt" in names) + val output = zip(folder) + assertTrue("steam/console_log.txt" in output) + assertTrue("steam/cef_log.previous.txt" in output) + assertTrue(output.getValue("steam/cef_log.previous.txt").contains("diagnostic file truncated")) + assertTrue(output.getValue("diagnostics-manifest.json").contains("\"status\": \"truncated\"")) } @Test fun streamingComparisonPreservesUnchangedFileAndReplacesChangedFile() { diff --git a/app/src/test/java/com/droiddeck/launcher/session/SessionLogShareZipTest.kt b/app/src/test/java/com/droiddeck/launcher/session/SessionLogShareZipTest.kt index ff7fd95108..ecc756553f 100644 --- a/app/src/test/java/com/droiddeck/launcher/session/SessionLogShareZipTest.kt +++ b/app/src/test/java/com/droiddeck/launcher/session/SessionLogShareZipTest.kt @@ -2,7 +2,6 @@ package com.droiddeck.launcher.session import com.droiddeck.launcher.runtime.LinuxRuntime import java.io.File -import java.nio.charset.StandardCharsets import java.text.SimpleDateFormat import java.util.Date import java.util.Locale @@ -38,23 +37,11 @@ class SessionLogShareZipTest { val zip = SessionLogShare.zipFolder(app, session)!! ZipFile(zip).use { archive -> val entry = archive.getEntry("${session.name}/steam-42.log")!! - archive.getInputStream(entry).use { input -> - val expected = "${com.droiddeck.launcher.core.LogRedactor.OVERSIZED_LINE}\n" - val prefix = ByteArray(expected.toByteArray(StandardCharsets.UTF_8).size) - var offset = 0 - while (offset < prefix.size) { - val count = input.read(prefix, offset, prefix.size - offset) - assertTrue("zip entry ended before its scrubbed prefix", count > 0) - offset += count - } - assertEquals(expected, String(prefix, StandardCharsets.UTF_8)) - input.bufferedReader().use { reader -> - val trailing = requireNotNull(reader.readLine()) - assertFalse("trailing secret survived", trailing.contains(trailingSecret)) - assertEquals("refresh_token=", trailing) - assertEquals(null, reader.readLine()) - } - } + val shared = archive.getInputStream(entry).bufferedReader().readText() + assertTrue(shared.contains("diagnostic file truncated")) + assertFalse("early secret survived", shared.contains(earlySecret)) + assertFalse("trailing secret survived", shared.contains(trailingSecret)) + assertTrue(shared.contains("refresh_token=")) } } finally { SessionLogShare.clear(app) diff --git a/app/src/test/java/com/droiddeck/launcher/session/SettingsResetTest.kt b/app/src/test/java/com/droiddeck/launcher/session/SettingsResetTest.kt index 83bba10460..e95a49608a 100644 --- a/app/src/test/java/com/droiddeck/launcher/session/SettingsResetTest.kt +++ b/app/src/test/java/com/droiddeck/launcher/session/SettingsResetTest.kt @@ -35,6 +35,7 @@ class SettingsResetTest { SessionPrefs.setResolutionChoice(app, SessionService.MODE_STEAM, "1280x800") SessionPrefs.setGuestHostname(app, "MyDeck") assertTrue(SessionPrefs.setGameDebugLogsEnabled(app, true)) + assertTrue(EnhancedDiagnostics.setArmed(app, true)) SessionPrefs.setHudShowFps(app, false) SessionPrefs.setHudShowBattery(app, false) SessionPrefs.setHudShowGraph(app, false) @@ -58,6 +59,7 @@ class SettingsResetTest { assertFalse(SessionPrefs.resolutionChosen(app, SessionService.MODE_STEAM)) assertEquals(SessionPrefs.DEFAULT_GUEST_HOSTNAME, SessionPrefs.guestHostname(app)) assertFalse(SessionPrefs.gameDebugLogsEnabled(app)) + assertFalse(EnhancedDiagnostics.isArmed(app)) val guest = java.io.File(com.droiddeck.launcher.runtime.LinuxRuntime.rootDir(app), "root/.config/droiddeck/game-environment.json") assertFalse(org.json.JSONObject(guest.readText()).getBoolean(GameEnvironmentStore.GAME_DEBUG_LOGS)) diff --git a/docs/development/game-environment.md b/docs/development/game-environment.md index 456e66cc6a..e0800784e9 100644 --- a/docs/development/game-environment.md +++ b/docs/development/game-environment.md @@ -116,6 +116,48 @@ logging can reduce performance and consume storage; disable it after collecting the report. If the session log directory is unavailable, the launcher reports that diagnostics were skipped instead of writing uncollected files elsewhere. +## Enhanced diagnostics + +Use **Setup > Diagnostics > Enhanced diagnostics for next session** when normal +session logs are not enough. The setting is one-shot: DroidDeck creates and +retains the next session's log directory, records the diagnostic profile, then +turns the setting off. It also enables the existing game diagnostic environment +for that session without changing the user's saved **Session logs** or **Game +debug logs** preferences. + +After reproducing the problem, use **Latest session logs > Share logs** or the +in-session share action. Enhanced sessions offer separate, correlated archives: + +| Archive | Main contents | +| --- | --- | +| Session and device | Startup timeline, device/component selection, app, audio, network, and exit summaries | +| Graphics | Graphics-related logs plus bounded Gamescope frame and process summaries when their providers are available | +| Games and compatibility | Proton, Wine, DXVK/VKD3D, FEX, store, and game lifecycle logs | + +Choose one archive when an issue calls for a narrow report, or **All bundles** +to share the three archives together. Every archive contains a +`diagnostics-manifest.json` with the common session ID and the state of each +artifact: captured, truncated, unavailable, omitted, or failed. Some captured +logs may themselves explain that a permission-limited source was unavailable. + +Exported archives sample a bounded amount of input. Large text logs retain +complete lines from their beginning and end, and the manifest records partial +scans and input limits. Raw game and component log writers are not yet safely byte-bounded while +the session is running; they can use substantial storage, particularly during a +long Proton game session. Enhanced diagnostics may also change timing because it +keeps the game wrapper alive long enough to record an exit status. Turn it on +only for a reproduction and review the archives before sharing them. + +The bundle does not promise unrestricted Android, kernel, or vendor-driver +logs. If accessible, Android's crash buffer can include reports from other apps; +redaction is best effort. Screen captures, pixels, input contents, memory dumps, +and full system traces are not included automatically. + +The Gamescope frame summary is produced only by a Gamescope build that includes +the enhanced frame-trace provider. An older bundled Gamescope safely ignores the +diagnostic environment setting; the Graphics archive then records no frame-trace +summary rather than inventing one. + A Unity game under FEX (`UnityPlayer.dll` for Windows builds under Proton, `UnityPlayer.so` or `GameAssembly.so` for native Linux builds started by **Linux x86 (FEX)**) keeps FEX's TSO on when the Default profile's FEX preset diff --git a/tools/gamescope/patches/0900-enhanced-frame-diagnostics.patch b/tools/gamescope/patches/0900-enhanced-frame-diagnostics.patch new file mode 100644 index 0000000000..1bd1573559 --- /dev/null +++ b/tools/gamescope/patches/0900-enhanced-frame-diagnostics.patch @@ -0,0 +1,333 @@ +diff --git a/src/Backends/WaylandBackend.cpp b/src/Backends/WaylandBackend.cpp +index 953765a..73ab9cc 100644 +--- a/src/Backends/WaylandBackend.cpp ++++ b/src/Backends/WaylandBackend.cpp +@@ -14,2 +14,3 @@ + #include "Utils/WaylandScaling.h" ++#include "droiddeck_frame_trace.hpp" + +@@ -1002,2 +1003,4 @@ namespace gamescope + ++ droiddeck::frame_trace::Record( droiddeck::frame_trace::Event::OutputRelease ); ++ + xdg_log.debugf( "buffer_release: %p", pBuffer ); +@@ -1079,2 +1082,3 @@ namespace gamescope + { ++ droiddeck::frame_trace::Record( droiddeck::frame_trace::Event::OutputPresent ); + UpdateFullscreenState(); +@@ -1485,2 +1489,3 @@ namespace gamescope + { ++ droiddeck::frame_trace::Record( droiddeck::frame_trace::Event::OutputAttach ); + assert( oState->pBuffer ); +@@ -1633,2 +1638,3 @@ namespace gamescope + { ++ droiddeck::frame_trace::Record( droiddeck::frame_trace::Event::OutputDetach ); + wl_surface_attach( m_pSurface, nullptr, 0, 0 ); +@@ -1650,2 +1656,3 @@ namespace gamescope + { ++ droiddeck::frame_trace::Record( droiddeck::frame_trace::Event::OutputCommit ); + if ( m_bNeedsDecorCommit ) +diff --git a/src/droiddeck_frame_trace.hpp b/src/droiddeck_frame_trace.hpp +new file mode 100644 +index 0000000..2c57f65 +--- /dev/null ++++ b/src/droiddeck_frame_trace.hpp +@@ -0,0 +1,191 @@ ++#pragma once ++ ++#include ++#include ++#include ++#include ++#include ++#include ++ ++#ifndef DROIDDECK_FRAME_TRACE_FAST_INTERVAL_MS ++#define DROIDDECK_FRAME_TRACE_FAST_INTERVAL_MS 2000 ++#endif ++#ifndef DROIDDECK_FRAME_TRACE_SLOW_INTERVAL_MS ++#define DROIDDECK_FRAME_TRACE_SLOW_INTERVAL_MS 15000 ++#endif ++#ifndef DROIDDECK_FRAME_TRACE_FAST_DURATION_MS ++#define DROIDDECK_FRAME_TRACE_FAST_DURATION_MS 120000 ++#endif ++#ifndef DROIDDECK_FRAME_TRACE_DURATION_MS ++#define DROIDDECK_FRAME_TRACE_DURATION_MS 86400000 ++#endif ++ ++namespace droiddeck::frame_trace ++{ ++ ++enum class Event : uint32_t ++{ ++ X11Damage, ++ X11DamageCurrent, ++ X11DamageOther, ++ SurfaceCommit, ++ SurfaceCommitBuffer, ++ SurfaceCommitNoBuffer, ++ CommitDequeued, ++ CommitDequeuedCurrent, ++ CommitDequeuedOther, ++ ImportSucceeded, ++ ImportSucceededCurrent, ++ ImportSucceededOther, ++ ImportFailed, ++ ImportFailedCurrent, ++ ImportFailedOther, ++ FenceReady, ++ FenceWaited, ++ CommitDone, ++ CommitDoneCurrent, ++ CommitDoneOther, ++ BaseLatched, ++ BaseLatchedCurrent, ++ BaseLatchedOther, ++ OutputPresent, ++ OutputAttach, ++ OutputDetach, ++ OutputCommit, ++ OutputRelease, ++ Count, ++}; ++ ++class State ++{ ++public: ++ State() ++ : m_enabled( EnabledByEnvironment() ) ++ { ++ } ++ ++ void Start() ++ { ++ if ( !m_enabled || m_started.exchange( true, std::memory_order_relaxed ) ) ++ return; ++ ++ m_startedAt = std::chrono::steady_clock::now(); ++ m_nextSummaryMs = kFastIntervalMs; ++ std::fprintf( stderr, ++ "DROIDDECK_FRAME_TRACE schema=1 fast_interval_ms=%ld slow_interval_ms=%ld " ++ "fast_duration_ms=%ld duration_ms=%ld\n", ++ kFastIntervalMs, kSlowIntervalMs, kFastDurationMs, kDurationMs ); ++ PrintSummary( 0 ); ++ } ++ ++ void Record( Event event ) ++ { ++ if ( !m_enabled || !m_started.load( std::memory_order_relaxed ) || ++ !m_active.load( std::memory_order_relaxed ) ) ++ return; ++ m_counts[static_cast( event )].fetch_add( 1, std::memory_order_relaxed ); ++ } ++ ++ void Tick() ++ { ++ if ( !m_enabled || !m_started.load( std::memory_order_relaxed ) || ++ !m_active.load( std::memory_order_relaxed ) ) ++ return; ++ ++ const int64_t elapsed = ElapsedMs(); ++ if ( elapsed >= kDurationMs ) ++ { ++ PrintSummary( kDurationMs ); ++ m_active.store( false, std::memory_order_relaxed ); ++ return; ++ } ++ if ( elapsed < m_nextSummaryMs ) ++ return; ++ ++ PrintSummary( elapsed ); ++ m_nextSummaryMs = elapsed + ( elapsed < kFastDurationMs ? kFastIntervalMs : kSlowIntervalMs ); ++ } ++ ++private: ++ static constexpr int64_t kFastIntervalMs = DROIDDECK_FRAME_TRACE_FAST_INTERVAL_MS; ++ static constexpr int64_t kSlowIntervalMs = DROIDDECK_FRAME_TRACE_SLOW_INTERVAL_MS; ++ static constexpr int64_t kFastDurationMs = DROIDDECK_FRAME_TRACE_FAST_DURATION_MS; ++ static constexpr int64_t kDurationMs = DROIDDECK_FRAME_TRACE_DURATION_MS; ++ ++ static bool EnabledByEnvironment() ++ { ++ const char *value = std::getenv( "DROIDDECK_ENHANCED_DIAGNOSTICS" ); ++ return value != nullptr && std::strcmp( value, "1" ) == 0; ++ } ++ ++ int64_t ElapsedMs() const ++ { ++ return std::chrono::duration_cast( ++ std::chrono::steady_clock::now() - m_startedAt ).count(); ++ } ++ ++ uint64_t Count( Event event ) const ++ { ++ return m_counts[static_cast( event )].load( std::memory_order_relaxed ); ++ } ++ ++ void PrintSummary( int64_t elapsed ) const ++ { ++ std::fprintf( stderr, ++ "DROIDDECK_FRAME_TRACE t_ms=%ld x11_damage=%lu x11_damage_current=%lu x11_damage_other=%lu " ++ "surface_commit=%lu surface_buffer=%lu surface_no_buffer=%lu dequeued=%lu dequeued_current=%lu " ++ "dequeued_other=%lu import_ok=%lu import_ok_current=%lu import_ok_other=%lu import_failed=%lu " ++ "import_failed_current=%lu import_failed_other=%lu fence_ready=%lu fence_waited=%lu commit_done=%lu " ++ "commit_done_current=%lu commit_done_other=%lu base_latched=%lu base_latched_current=%lu " ++ "base_latched_other=%lu output_present=%lu output_attach=%lu " ++ "output_detach=%lu output_commit=%lu output_release=%lu\n", ++ elapsed, ++ Count( Event::X11Damage ), Count( Event::X11DamageCurrent ), Count( Event::X11DamageOther ), ++ Count( Event::SurfaceCommit ), Count( Event::SurfaceCommitBuffer ), Count( Event::SurfaceCommitNoBuffer ), ++ Count( Event::CommitDequeued ), Count( Event::CommitDequeuedCurrent ), Count( Event::CommitDequeuedOther ), ++ Count( Event::ImportSucceeded ), Count( Event::ImportSucceededCurrent ), Count( Event::ImportSucceededOther ), ++ Count( Event::ImportFailed ), Count( Event::ImportFailedCurrent ), Count( Event::ImportFailedOther ), ++ Count( Event::FenceReady ), Count( Event::FenceWaited ), Count( Event::CommitDone ), ++ Count( Event::CommitDoneCurrent ), Count( Event::CommitDoneOther ), Count( Event::BaseLatched ), ++ Count( Event::BaseLatchedCurrent ), Count( Event::BaseLatchedOther ), Count( Event::OutputPresent ), ++ Count( Event::OutputAttach ), Count( Event::OutputDetach ), Count( Event::OutputCommit ), ++ Count( Event::OutputRelease ) ); ++ std::fflush( stderr ); ++ } ++ ++ bool m_enabled; ++ std::atomic m_started{ false }; ++ std::atomic m_active{ true }; ++ std::chrono::steady_clock::time_point m_startedAt{}; ++ int64_t m_nextSummaryMs = 0; ++ std::atomic m_counts[static_cast( Event::Count )]{}; ++}; ++ ++inline State &GetState() ++{ ++ static State state; ++ return state; ++} ++ ++inline void Start() ++{ ++ GetState().Start(); ++} ++ ++inline void Record( Event event ) ++{ ++ GetState().Record( event ); ++} ++ ++inline void RecordWindow( Event total, Event focused, Event other, bool isFocused ) ++{ ++ Record( total ); ++ Record( isFocused ? focused : other ); ++} ++ ++inline void Tick() ++{ ++ GetState().Tick(); ++} ++ ++} +diff --git a/src/main.cpp b/src/main.cpp +index eef4264..1d22ba4 100644 +--- a/src/main.cpp ++++ b/src/main.cpp +@@ -35,2 +35,3 @@ + #include "Utils/Version.h" ++#include "droiddeck_frame_trace.hpp" + +@@ -718,2 +719,3 @@ int main(int argc, char **argv) + g_argv = argv; ++ droiddeck::frame_trace::Start(); + +diff --git a/src/steamcompmgr.cpp b/src/steamcompmgr.cpp +index b4c6830..46e7a6c 100644 +--- a/src/steamcompmgr.cpp ++++ b/src/steamcompmgr.cpp +@@ -32,2 +32,3 @@ + #include "backend.h" ++#include "droiddeck_frame_trace.hpp" + #include "gamescope_shared.h" +@@ -6419,2 +6420,9 @@ damage_win(xwayland_ctx_t *ctx, XDamageNotifyEvent *de) + ++ global_focus_t *pTraceFocus = GetCurrentFocus(); ++ droiddeck::frame_trace::RecordWindow( ++ droiddeck::frame_trace::Event::X11Damage, ++ droiddeck::frame_trace::Event::X11DamageCurrent, ++ droiddeck::frame_trace::Event::X11DamageOther, ++ pTraceFocus != nullptr && pTraceFocus->focusWindow == w ); ++ + if (w->IsAnyOverlay() && !w->opacity) +@@ -7999,2 +8007,8 @@ bool handle_done_commit( steamcompmgr_win_t *w, xwayland_ctx_t *ctx, uint64_t co + { ++ global_focus_t *pTraceFocus = GetCurrentFocus(); ++ droiddeck::frame_trace::RecordWindow( ++ droiddeck::frame_trace::Event::CommitDone, ++ droiddeck::frame_trace::Event::CommitDoneCurrent, ++ droiddeck::frame_trace::Event::CommitDoneOther, ++ pTraceFocus != nullptr && pTraceFocus->focusWindow == w ); + gpuvis_trace_printf( "commit %lu done", w->commit_queue[ j ]->commitID ); +@@ -8049,3 +8063,10 @@ bool handle_done_commit( steamcompmgr_win_t *w, xwayland_ctx_t *ctx, uint64_t co + if ( !cv_paint_debug_pause_base_plane ) ++ { + pFocus->HeldCommits[ HELD_COMMIT_BASE ] = w->commit_queue[ j ]; ++ droiddeck::frame_trace::RecordWindow( ++ droiddeck::frame_trace::Event::BaseLatched, ++ droiddeck::frame_trace::Event::BaseLatchedCurrent, ++ droiddeck::frame_trace::Event::BaseLatchedOther, ++ pFocus == GetCurrentFocus() ); ++ } + hasRepaint = true; +@@ -8397,2 +8418,4 @@ static void note_commit_fence( bool bReadyAtImport ) + { ++ droiddeck::frame_trace::Record( bReadyAtImport ? droiddeck::frame_trace::Event::FenceReady ++ : droiddeck::frame_trace::Event::FenceWaited ); + static uint64_t s_ulReady = 0, s_ulWaited = 0, s_ulLastLog = 0; +@@ -8412,2 +8435,9 @@ void update_wayland_res(const std::shared_ptr &doneCommits, st + { ++ global_focus_t *pTraceFocus = GetCurrentFocus(); ++ const bool bTraceCurrent = pTraceFocus != nullptr && pTraceFocus->focusWindow == w; ++ droiddeck::frame_trace::RecordWindow( ++ droiddeck::frame_trace::Event::CommitDequeued, ++ droiddeck::frame_trace::Event::CommitDequeuedCurrent, ++ droiddeck::frame_trace::Event::CommitDequeuedOther, ++ bTraceCurrent ); + struct wlr_buffer *buf = reslistentry.buf; +@@ -8501,2 +8531,7 @@ void update_wayland_res(const std::shared_ptr &doneCommits, st + { ++ droiddeck::frame_trace::RecordWindow( ++ droiddeck::frame_trace::Event::ImportFailed, ++ droiddeck::frame_trace::Event::ImportFailedCurrent, ++ droiddeck::frame_trace::Event::ImportFailedOther, ++ bTraceCurrent ); + // Import failed to import, early exit. +@@ -8504,2 +8539,7 @@ void update_wayland_res(const std::shared_ptr &doneCommits, st + } ++ droiddeck::frame_trace::RecordWindow( ++ droiddeck::frame_trace::Event::ImportSucceeded, ++ droiddeck::frame_trace::Event::ImportSucceededCurrent, ++ droiddeck::frame_trace::Event::ImportSucceededOther, ++ bTraceCurrent ); + +@@ -8679,3 +8719,2 @@ void update_wayland_res(const std::shared_ptr &doneCommits, st + } +- + gpuvis_trace_printf( "pushing wait for commit %lu win %lx", newCommit->commitID, w->type == steamcompmgr_win_type_t::XWAYLAND ? w->xwayland().id : 0 ); +@@ -10256,2 +10295,3 @@ steamcompmgr_main(int argc, char **argv) + { ++ droiddeck::frame_trace::Tick(); + { +diff --git a/src/wlserver.cpp b/src/wlserver.cpp +index 5733871..ed4dbc3 100644 +--- a/src/wlserver.cpp ++++ b/src/wlserver.cpp +@@ -24,2 +24,3 @@ + #include "WaylandServer/GamescopeLimiter.h" ++#include "droiddeck_frame_trace.hpp" + +@@ -210,2 +211,8 @@ void xwayland_surface_commit(struct wlr_surface *wlr_surface) { + ++ droiddeck::frame_trace::Record( droiddeck::frame_trace::Event::SurfaceCommit ); ++ droiddeck::frame_trace::Record( ++ ( wlr_surface->current.committed & WLR_SURFACE_STATE_BUFFER ) ++ ? droiddeck::frame_trace::Event::SurfaceCommitBuffer ++ : droiddeck::frame_trace::Event::SurfaceCommitNoBuffer ); ++ + wlr_surface->current.committed = 0; + diff --git a/tools/linuxfs/overlay/usr/local/bin/droiddeck-diagnostic-inventory b/tools/linuxfs/overlay/usr/local/bin/droiddeck-diagnostic-inventory new file mode 100755 index 0000000000..947c5bb1c3 --- /dev/null +++ b/tools/linuxfs/overlay/usr/local/bin/droiddeck-diagnostic-inventory @@ -0,0 +1,446 @@ +#!/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()) diff --git a/tools/linuxfs/overlay/usr/local/bin/droiddeck-game-env b/tools/linuxfs/overlay/usr/local/bin/droiddeck-game-env index 5624cbc2be..ac7cd5189c 100755 --- a/tools/linuxfs/overlay/usr/local/bin/droiddeck-game-env +++ b/tools/linuxfs/overlay/usr/local/bin/droiddeck-game-env @@ -970,7 +970,7 @@ def ego_core_plan(command, env): return "%s had no thread plan for %d cores; added a copy of its %s-core plan" % (EGO_RESTRICTIONS, count, source.group(2)) -def wait_forwarding_signals(process): +def wait_forwarding_signals_raw(process): def forward(signum, frame): try: process.send_signal(signum) @@ -983,22 +983,55 @@ def wait_forwarding_signals(process): finally: for signum, handler in previous.items(): signal.signal(signum, handler) + return code + + +def wait_forwarding_signals(process): + code = wait_forwarding_signals_raw(process) return 128 - code if code < 0 else code -def start(launch, launch_env, digest, after=None): +def diagnostic_game_event(event, app_id, values=None): + fields = ["event=" + event, "app_id=" + app_id] + fields.extend("%s=%s" % item for item in (values or {}).items()) + print("DROIDDECK_DIAGNOSTICS " + " ".join(fields), file=sys.stderr, flush=True) + + +def diagnostic_game_exit(app_id, raw_code, source=None, wrapper_status=None): + normalized = 128 - raw_code if raw_code < 0 else raw_code + values = { + "raw_status": raw_code, + "normalized_status": normalized, + "wrapper_status": normalized if wrapper_status is None else wrapper_status, + "signal": -raw_code if raw_code < 0 else 0, + } + if source is not None: + values["source"] = source + diagnostic_game_event("game_exit", app_id, values) + + +def start(launch, launch_env, digest, after=None, diagnostic_app_id=None): if len(launch) > 1 and launch[1] == "waitforexitandrun": ubisoft_composition_off(launch[0], launch_env) - if after: + if after or diagnostic_app_id is not None: process = subprocess.Popen(launch, env=launch_env) + if diagnostic_app_id is not None: + diagnostic_game_event("game_start", diagnostic_app_id) try: - return wait_forwarding_signals(process) + raw_code = wait_forwarding_signals_raw(process) finally: - try: - after() - except OSError as error: - print("droiddeck-game-env: DiRT telemetry fix: prefix ws2_32 not put back (%s); the next launch does it" % error, - file=sys.stderr) + if after: + try: + after() + except OSError as error: + print("droiddeck-game-env: DiRT telemetry fix: prefix ws2_32 not put back (%s); the next launch does it" % error, + file=sys.stderr) + code = 128 - raw_code if raw_code < 0 else raw_code + if digest and after is None and code == 0: + record_install_scripts(digest, launch_env) + if diagnostic_app_id is not None: + diagnostic_game_exit(diagnostic_app_id, raw_code) + return code if digest: code = subprocess.run(launch, env=launch_env, check=False).returncode if code == 0: @@ -1023,10 +1056,11 @@ def main(): except OSError: digest = None app_id = game_id(env) + waiting = bool(app_id and len(command) > 1 and command[1] == "waitforexitandrun") + diagnostic_app_id = app_id if waiting and os.environ.get("DROIDDECK_ENHANCED_DIAGNOSTICS") == "1" else None dirt_prefix = None if app_id: gl_default = gl_vsync(env) - waiting = len(command) > 1 and command[1] == "waitforexitandrun" if waiting: game_images(env) fixes = {} @@ -1104,6 +1138,8 @@ def main(): print("droiddeck-game-env: Xbox launch could not start (%s)" % error, file=sys.stderr) return 1 if xbox_result is not None: + if diagnostic_app_id is not None and isinstance(xbox_result, int): + diagnostic_game_exit(diagnostic_app_id, xbox_result, "xbox", xbox_result % 256) return xbox_result after = None prefix = env.get("STEAM_COMPAT_DATA_PATH", "").rstrip("/") @@ -1129,13 +1165,13 @@ def main(): launch, launch_env = select_sync(command, env, sync) if launch[0] != command[0]: try: - return start(launch, launch_env, digest, after) + return start(launch, launch_env, digest, after, diagnostic_app_id) 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) try: - return start(launch, launch_env, digest, after) + return start(launch, launch_env, digest, after, diagnostic_app_id) except OSError: if after: try: diff --git a/tools/linuxfs/overlay/usr/local/bin/droiddeck-session b/tools/linuxfs/overlay/usr/local/bin/droiddeck-session index 9f7747c6a5..4ebfbc00ea 100755 --- a/tools/linuxfs/overlay/usr/local/bin/droiddeck-session +++ b/tools/linuxfs/overlay/usr/local/bin/droiddeck-session @@ -22,6 +22,19 @@ if [ -n "${BL_LOG:-}" ] && [ -z "${BL_INSIDE:-}" ]; then echo "== rootfs: $(cat /.version 2>/dev/null || echo unversioned)" fi +start_diagnostic_inventory() { + [ "${DROIDDECK_ENHANCED_DIAGNOSTICS:-0}" = 1 ] || return 0 + [ -z "${BL_INSIDE:-}" ] || return 0 + if ! command -v droiddeck-diagnostic-inventory >/dev/null 2>&1; then + printf '%s\n' 'DROIDDECK_PROCESS_TRACE {"schema":1,"event":"provider","status":"unavailable"}' + return 0 + fi + droiddeck-diagnostic-inventory --watch --root-pid "$$" & + _bl_diagnostic_inventory=$! + trap 'kill "$_bl_diagnostic_inventory" 2>/dev/null || true; wait "$_bl_diagnostic_inventory" 2>/dev/null || true' EXIT +} +start_diagnostic_inventory + sync_timezone() { local zone=${TZ:-} case "$zone" in ''|/*|*..*) return 0 ;; esac @@ -141,8 +154,13 @@ run_gamescope() ( BL_STEAM_EXIT_FILE="$status_file" gamescope "$@" compositor_status=$? if read -r child_status < "$status_file" && [[ $child_status =~ ^[0-9]{1,3}$ ]] \ - && [ "$child_status" -gt 0 ] && [ "$child_status" -le 255 ]; then - exit "$child_status" + && [ "$child_status" -le 255 ]; then + if [ "${DROIDDECK_ENHANCED_DIAGNOSTICS:-0}" = 1 ]; then + printf 'DROIDDECK_DIAGNOSTICS event=session_exit compositor_status=%s steam_status=%s\n' "$compositor_status" "$child_status" + fi + [ "$child_status" -eq 0 ] || exit "$child_status" + elif [ "${DROIDDECK_ENHANCED_DIAGNOSTICS:-0}" = 1 ]; then + printf 'DROIDDECK_DIAGNOSTICS event=session_exit compositor_status=%s steam_status=unavailable\n' "$compositor_status" fi exit "$compositor_status" ) @@ -1489,6 +1507,9 @@ case $mode in wait "$desktop_ui_pid" 2>/dev/null || true fi echo "== steam exited rc=$rc" + if [ "${DROIDDECK_ENHANCED_DIAGNOSTICS:-0}" = 1 ]; then + printf 'DROIDDECK_DIAGNOSTICS event=steam_exit shell_status=%s elapsed_seconds=%s\n' "$rc" "$steam_ran" + fi 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 diff --git a/tools/tests/test_diagnostic_inventory.py b/tools/tests/test_diagnostic_inventory.py new file mode 100644 index 0000000000..9283f064ec --- /dev/null +++ b/tools/tests/test_diagnostic_inventory.py @@ -0,0 +1,234 @@ +import io +import json +import os +from pathlib import Path +import runpy +import tempfile +import unittest + + +ROOT = Path(__file__).resolve().parents[2] +SCRIPT = ROOT / "tools/linuxfs/overlay/usr/local/bin/droiddeck-diagnostic-inventory" +MODULE = runpy.run_path(str(SCRIPT), run_name="droiddeck_diagnostic_inventory") + + +def write_process(root, pid, ppid, start, comm, cmdline, maps=None): + process = root / str(pid) + process.mkdir(parents=True) + children = process / "task" / str(pid) / "children" + children.parent.mkdir(parents=True) + children.write_text("") + fields = ["S", str(ppid)] + ["0"] * 17 + [str(start)] + (process / "stat").write_text(f"{pid} ({comm}) " + " ".join(fields) + "\n") + (process / "comm").write_text(comm + "\n") + (process / "cmdline").write_bytes(cmdline.replace(" ", "\0").encode() + b"\0") + if maps is not None: + (process / "maps").write_text("".join( + f"1000-2000 r-xp 00000000 00:00 0 {path}\n" for path in maps + )) + parent_children = root / str(ppid) / "task" / str(ppid) / "children" + if parent_children.is_file(): + existing = parent_children.read_text().split() + if str(pid) not in existing: + parent_children.write_text(" ".join(existing + [str(pid)]) + "\n") + return process + + +def rows(text): + prefix = MODULE["PREFIX"] + return [json.loads(line.removeprefix(prefix)) for line in text.splitlines() if line.startswith(prefix)] + + +class DiagnosticInventoryTest(unittest.TestCase): + def test_default_off_produces_no_output(self): + with tempfile.TemporaryDirectory() as directory: + output = io.StringIO() + result = MODULE["main"]( + ["--once", "--root-pid", "100", "--proc-root", directory], {}, output, + ) + self.assertEqual(result, 0) + self.assertEqual(output.getvalue(), "") + + def test_once_scopes_processes_and_reports_only_safe_graphics_identity(self): + with tempfile.TemporaryDirectory() as directory: + proc = Path(directory) + write_process(proc, 100, 1, 10, "droiddeck-session", "/usr/local/bin/droiddeck-session steam", [ + "/usr/lib/libvulkan.so.1", + ]) + write_process(proc, 101, 100, 11, "steam", "/secret/account/steam -login private-token", [ + "/data/user/0/com.droiddeck.launcher/files/components/system-vulkan/abc/libVkLayer_hybris_compat.so", + "/data/user/0/com.droiddeck.launcher/files/components/system-vulkan/abc/libvulkan-private-account.so", + "/data/user/0/com.droiddeck.launcher/files/components/system-vulkan/abc/libdrm_accountSecret.so", + "/data/user/0/com.droiddeck.launcher/files/components/system-vulkan/abc/libxcb-sessionSecret.so", + "/data/user/0/com.droiddeck.launcher/files/components/system-vulkan/abc/libvkd3d-userSecret.so", + "/data/user/0/com.droiddeck.launcher/files/components/system-vulkan/abc/libdrm_amdgpu.so.1.0.0", + "/home/private-user/not-graphics-secret.so", + "/home/private-user/libvulkan-private-user.so", + ]) + write_process(proc, 102, 101, 12, "steamwebhelper", "steamwebhelper --user-data-dir=/secret/profile", [ + "/vendor/lib64/hw/vulkan.samsung.so", + "/tmp/libvulkan-secret with spaces.so", + ]) + write_process(proc, 103, 101, 13, "private-game-title", "private-game-title --token=child-secret", []) + write_process(proc, 200, 1, 20, "unrelated", "unrelated --password=hunter2", [ + "/vendor/lib64/hw/vulkan.unrelated.so", + ]) + output = io.StringIO() + MODULE["main"]( + ["--once", "--root-pid", "100", "--proc-root", directory], + {"DROIDDECK_ENHANCED_DIAGNOSTICS": "1"}, output, + ) + payloads = rows(output.getvalue()) + self.assertEqual(payloads[0]["event"], "provider") + snapshot = payloads[1] + self.assertEqual(snapshot["alive"], 4) + self.assertEqual(snapshot["roles"], { + "game-or-helper": 1, "session": 1, "steam-client": 1, "steam-webhelper": 1, + }) + self.assertEqual(snapshot["providerStatus"], "available") + self.assertEqual(snapshot["scopeMethod"], "children") + self.assertFalse(snapshot["scopeIncomplete"]) + libraries = {(item["name"], item["origin"]) for item in snapshot["libraries"]} + self.assertIn(("libvulkan.so.1", "guest-runtime"), libraries) + self.assertIn(("libVkLayer_hybris_compat.so", "droiddeck-component"), libraries) + self.assertIn(("libdrm_amdgpu.so.1.0.0", "droiddeck-component"), libraries) + self.assertIn(("vulkan.samsung.so", "android-vendor"), libraries) + self.assertTrue(any(name.startswith("sha256:") and origin == "other" for name, origin in libraries)) + self.assertGreaterEqual(sum(name.startswith("sha256:") and origin == "droiddeck-component" + for name, origin in libraries), 4) + text = output.getvalue() + for secret in ("private-token", "private-user", "child-secret", "private-game-title", "hunter2", + "accountSecret", "sessionSecret", "userSecret", "unrelated", "/vendor/", "/data/user/"): + self.assertNotIn(secret, text) + + def test_missing_maps_and_proc_are_explicit(self): + with tempfile.TemporaryDirectory() as directory: + proc = Path(directory) + write_process(proc, 100, 1, 10, "droiddeck-session", "droiddeck-session") + collector = MODULE["Collector"](proc, 100) + snapshot, _ = collector.scan() + self.assertEqual(snapshot["maps"]["unavailable"], 1) + self.assertEqual(snapshot["providerStatus"], "available") + missing = MODULE["Collector"](proc / "missing", 100) + snapshot, _ = missing.scan() + self.assertEqual(snapshot["providerStatus"], "proc-unavailable") + + def test_children_fallback_is_explicitly_incomplete(self): + with tempfile.TemporaryDirectory() as directory: + proc = Path(directory) + process = write_process(proc, 100, 1, 10, "droiddeck-session", "droiddeck-session", []) + write_process(proc, 101, 100, 11, "steam", "steam", []) + (process / "task" / "100" / "children").unlink() + collector = MODULE["Collector"](proc, 100) + snapshot, _ = collector.scan() + self.assertEqual(snapshot["alive"], 2) + self.assertEqual(snapshot["scopeMethod"], "children+scan-fallback") + self.assertTrue(snapshot["scopeIncomplete"]) + + def test_pid_reuse_is_an_exit_and_a_new_process(self): + with tempfile.TemporaryDirectory() as directory: + proc = Path(directory) + write_process(proc, 99, 1, 9, "droiddeck-session", "droiddeck-session", []) + process = write_process(proc, 100, 99, 10, "steam", "steam", []) + collector = MODULE["Collector"](proc, 99) + first, _ = collector.scan() + first_token = next(row["token"] for row in first["started"] if row["role"] == "steam-client") + fields = ["S", "99"] + ["0"] * 17 + ["20"] + (process / "stat").write_text("100 (steam) " + " ".join(fields) + "\n") + second, changed = collector.scan() + self.assertTrue(changed) + self.assertEqual(next(row["token"] for row in second["exited"] if row["role"] == "steam-client"), first_token) + self.assertNotEqual( + next(row["token"] for row in second["started"] if row["role"] == "steam-client"), first_token, + ) + + def test_exec_role_change_is_reported_without_pid_reuse(self): + with tempfile.TemporaryDirectory() as directory: + proc = Path(directory) + process = write_process(proc, 100, 1, 10, "droiddeck-session", "droiddeck-session", []) + collector = MODULE["Collector"](proc, 100) + collector.scan() + (process / "comm").write_text("gamescope\n") + (process / "cmdline").write_bytes(b"gamescope\0--backend\0wayland\0") + snapshot, changed = collector.scan() + self.assertTrue(changed) + self.assertEqual(snapshot["roles"], {"gamescope": 1}) + + def test_process_scope_is_bounded(self): + with tempfile.TemporaryDirectory() as directory: + proc = Path(directory) + write_process(proc, 100, 1, 10, "droiddeck-session", "droiddeck-session", []) + for pid in range(101, 370): + write_process(proc, pid, 100, pid, "helper", "helper", []) + collector = MODULE["Collector"](proc, 100) + snapshot, _ = collector.scan() + self.assertLessEqual(snapshot["alive"], MODULE["MAX_PROCESSES"]) + self.assertTrue(snapshot["scopeCapped"]) + + def test_reused_root_pid_is_not_adopted(self): + with tempfile.TemporaryDirectory() as directory: + proc = Path(directory) + process = write_process(proc, 100, 1, 10, "droiddeck-session", "droiddeck-session", []) + collector = MODULE["Collector"](proc, 100) + collector.scan() + fields = ["S", "1"] + ["0"] * 17 + ["20"] + (process / "stat").write_text("100 (unrelated-app) " + " ".join(fields) + "\n") + snapshot, _ = collector.scan() + self.assertEqual(snapshot["providerStatus"], "root-reused") + self.assertEqual(snapshot["alive"], 0) + self.assertNotIn("unrelated-app", json.dumps(snapshot)) + + def test_reparented_child_is_rejected_after_process_reads(self): + with tempfile.TemporaryDirectory() as directory: + proc = Path(directory) + write_process(proc, 100, 1, 10, "droiddeck-session", "droiddeck-session", []) + child = write_process(proc, 101, 100, 11, "steam", "steam", []) + globals_ = MODULE["Collector"].scan.__globals__ + original = globals_["process_stat"] + calls = 0 + + def racing(path): + nonlocal calls + if path == child / "stat": + calls += 1 + if calls == 3: + fields = ["S", "1"] + ["0"] * 17 + ["11"] + path.write_text("101 (steam) " + " ".join(fields) + "\n") + return original(path) + + globals_["process_stat"] = racing + try: + collector = MODULE["Collector"](proc, 100) + snapshot, _ = collector.scan() + finally: + globals_["process_stat"] = original + self.assertEqual(snapshot["roles"], {"session": 1}) + self.assertEqual(snapshot["alive"], 1) + + def test_watch_is_bounded_and_emits_heartbeats_without_process_changes(self): + globals_ = MODULE["main"].__globals__ + original = globals_["HEARTBEAT_MS"] + globals_["HEARTBEAT_MS"] = 40 + try: + with tempfile.TemporaryDirectory() as directory: + proc = Path(directory) + write_process(proc, 100, 1, 10, "droiddeck-session", "droiddeck-session", []) + output = io.StringIO() + MODULE["main"]( + ["--watch", "--root-pid", "100", "--proc-root", directory, + "--interval-ms", "250", "--duration-ms", "520", "--max-records", "4"], + {"DROIDDECK_ENHANCED_DIAGNOSTICS": "1"}, output, + ) + payloads = rows(output.getvalue()) + self.assertEqual(payloads[0]["event"], "provider") + self.assertEqual(payloads[1]["event"], "snapshot") + self.assertEqual(payloads[2]["event"], "heartbeat") + self.assertNotIn("libraries", payloads[2]) + self.assertTrue(payloads[2]["librariesUnchanged"]) + self.assertLessEqual(len(payloads), 4) + finally: + globals_["HEARTBEAT_MS"] = original + + +if __name__ == "__main__": + unittest.main() diff --git a/tools/tests/test_diagnostic_session_integration.py b/tools/tests/test_diagnostic_session_integration.py new file mode 100644 index 0000000000..2b55199092 --- /dev/null +++ b/tools/tests/test_diagnostic_session_integration.py @@ -0,0 +1,50 @@ +import os +from pathlib import Path +import re +import subprocess +import tempfile +import unittest + + +SESSION = Path(__file__).resolve().parents[1] / 'linuxfs/overlay/usr/local/bin/droiddeck-session' + + +class DiagnosticSessionIntegrationTest(unittest.TestCase): + def run_inventory(self, enabled, inside=False, installed=True): + source = SESSION.read_text() + match = re.search(r'^start_diagnostic_inventory\(\) \{\n.*?^\}\n', source, re.M | re.S) + self.assertIsNotNone(match) + with tempfile.TemporaryDirectory() as directory: + root = Path(directory) + marker = root / 'called' + if installed: + helper = root / 'droiddeck-diagnostic-inventory' + helper.write_text('#!/bin/bash\nprintf "%s\\n" "$@" > "$MARKER"\n') + helper.chmod(0o755) + env = dict(os.environ, PATH=str(root) + os.pathsep + os.environ['PATH'], + MARKER=str(marker), DROIDDECK_ENHANCED_DIAGNOSTICS='1' if enabled else '0') + env['BL_INSIDE'] = '1' if inside else '' + script = match.group() + '\nstart_diagnostic_inventory\n' + if installed and enabled and not inside: + script += 'wait "$_bl_diagnostic_inventory"\n' + result = subprocess.run(['bash', '-c', script], env=env, capture_output=True, text=True, timeout=10) + self.assertEqual(result.returncode, 0, result.stderr) + return marker.read_text().splitlines() if marker.exists() else [], result.stdout + + def test_starts_for_an_enhanced_outer_session(self): + arguments, _ = self.run_inventory(True) + self.assertEqual(arguments[:2], ['--watch', '--root-pid']) + self.assertTrue(arguments[2].isdigit()) + + def test_does_not_start_when_disabled_or_inside_gamescope(self): + self.assertEqual(self.run_inventory(False)[0], []) + self.assertEqual(self.run_inventory(True, inside=True)[0], []) + + def test_reports_when_the_provider_is_not_installed(self): + _, output = self.run_inventory(True, installed=False) + self.assertIn('DROIDDECK_PROCESS_TRACE', output) + self.assertIn('"status":"unavailable"', output) + + +if __name__ == '__main__': + unittest.main() diff --git a/tools/tests/test_game_exit_diagnostics.py b/tools/tests/test_game_exit_diagnostics.py new file mode 100644 index 0000000000..262366b5e6 --- /dev/null +++ b/tools/tests/test_game_exit_diagnostics.py @@ -0,0 +1,186 @@ +import contextlib +import io +import os +from pathlib import Path +import runpy +import signal +import subprocess +import sys +import tempfile +from unittest import mock +import unittest + + +BIN = Path(__file__).resolve().parents[1] / "linuxfs/overlay/usr/local/bin" +GAME_ENV = BIN / "droiddeck-game-env" +MODULE = runpy.run_path(str(GAME_ENV)) + + +class GameExitDiagnosticsTest(unittest.TestCase): + def run_child(self, body, app_id="42"): + with contextlib.redirect_stderr(io.StringIO()) as said: + status = MODULE["start"]( + [sys.executable, "-c", body], os.environ.copy(), None, + diagnostic_app_id=app_id, + ) + return status, said.getvalue() + + def test_clean_and_nonzero_exits_are_authoritative(self): + for child_status in (0, 7): + with self.subTest(status=child_status): + status, said = self.run_child("import sys; sys.exit(%d)" % child_status) + self.assertEqual(status, child_status) + self.assertIn("event=game_start app_id=42", said) + self.assertIn( + "event=game_exit app_id=42 raw_status=%d normalized_status=%d wrapper_status=%d signal=0" % + (child_status, child_status, child_status), said, + ) + + def test_signal_exit_is_normalized_and_records_the_signal(self): + status, said = self.run_child("import os, signal; os.kill(os.getpid(), signal.SIGTERM)") + self.assertEqual(status, 128 + signal.SIGTERM) + self.assertIn( + "event=game_exit app_id=42 raw_status=-15 normalized_status=143 wrapper_status=143 signal=15", said, + ) + + def test_xbox_exit_is_recorded_without_inventing_a_start(self): + with contextlib.redirect_stderr(io.StringIO()) as said: + MODULE["diagnostic_game_exit"]("42", -signal.SIGTERM, "xbox", 241) + self.assertNotIn("event=game_start", said.getvalue()) + self.assertIn( + "event=game_exit app_id=42 raw_status=-15 normalized_status=143 wrapper_status=241 signal=15 source=xbox", + said.getvalue(), + ) + + def test_signal_handler_forwards_to_the_child(self): + class Process: + def __init__(self): + self.forwarded = [] + + def send_signal(self, signum): + self.forwarded.append(signum) + + def wait(self): + os.kill(os.getpid(), signal.SIGTERM) + return -signal.SIGTERM + + process = Process() + self.assertEqual(MODULE["wait_forwarding_signals"](process), 128 + signal.SIGTERM) + self.assertEqual(process.forwarded, [signal.SIGTERM]) + + def test_default_path_still_execs_in_place_without_diagnostic_output(self): + called = [] + with mock.patch("os.execvpe", side_effect=lambda *args: called.append(args)), \ + contextlib.redirect_stderr(io.StringIO()) as said: + MODULE["start"](["/game", "arg"], {"A": "B"}, None) + self.assertEqual(called, [("/game", ["/game", "arg"], {"A": "B"})]) + self.assertNotIn("DROIDDECK_DIAGNOSTICS", said.getvalue()) + + def test_failed_selected_launch_does_not_invent_a_start_or_exit(self): + with mock.patch("subprocess.Popen", side_effect=FileNotFoundError("missing")), \ + contextlib.redirect_stderr(io.StringIO()) as said: + with self.assertRaises(FileNotFoundError): + MODULE["start"](["/missing"], {}, None, diagnostic_app_id="42") + self.assertNotIn("DROIDDECK_DIAGNOSTICS", said.getvalue()) + + def test_cleanup_runs_after_a_diagnostic_child(self): + cleaned = [] + with contextlib.redirect_stderr(io.StringIO()): + status = MODULE["start"]( + [sys.executable, "-c", "pass"], os.environ.copy(), None, + after=lambda: cleaned.append(True), diagnostic_app_id="42", + ) + self.assertEqual(status, 0) + self.assertEqual(cleaned, [True]) + + def test_diagnostic_install_script_keeps_success_recording(self): + recorded = [] + with mock.patch.dict(MODULE["start"].__globals__, record_install_scripts=lambda digest, env: recorded.append((digest, env))), \ + contextlib.redirect_stderr(io.StringIO()): + status = MODULE["start"]( + [sys.executable, "-c", "pass"], {"CUSTOM": "kept"}, "digest", + diagnostic_app_id="42", + ) + self.assertEqual(status, 0) + self.assertEqual(recorded, [("digest", {"CUSTOM": "kept"})]) + + def test_cleanup_path_keeps_the_original_install_recording_precedence(self): + recorded = [] + with mock.patch.dict(MODULE["start"].__globals__, record_install_scripts=lambda digest, env: recorded.append((digest, env))): + status = MODULE["start"]( + [sys.executable, "-c", "pass"], {"CUSTOM": "kept"}, "digest", + after=lambda: None, + ) + self.assertEqual(status, 0) + self.assertEqual(recorded, []) + + def test_main_only_traces_valid_waitforexitandrun_games(self): + with tempfile.TemporaryDirectory(prefix="game-exit-diagnostics-") as directory: + root = Path(directory) + probe = root / "probe" + probe.write_text("#!" + sys.executable + "\nimport sys\nsys.exit(7)\n") + probe.chmod(0o755) + base = dict(os.environ, HOME=directory, PATH=os.defpath, + DROIDDECK_ENHANCED_DIAGNOSTICS="1") + valid = subprocess.run( + [sys.executable, str(GAME_ENV), str(probe), "waitforexitandrun"], + env={**base, "STEAM_COMPAT_DATA_PATH": "/compatdata/42"}, + capture_output=True, text=True, timeout=15, + ) + self.assertEqual(valid.returncode, 7, valid.stderr) + self.assertIn("event=game_start app_id=42", valid.stderr) + self.assertIn( + "event=game_exit app_id=42 raw_status=7 normalized_status=7 wrapper_status=7 signal=0", valid.stderr, + ) + + for verb, prefix in (("run", "/compatdata/42"), ("waitforexitandrun", "/compatdata/not-a-game")): + result = subprocess.run( + [sys.executable, str(GAME_ENV), str(probe), verb], + env={**base, "STEAM_COMPAT_DATA_PATH": prefix}, + capture_output=True, text=True, timeout=15, + ) + self.assertEqual(result.returncode, 7, result.stderr) + self.assertNotIn("DROIDDECK_DIAGNOSTICS", result.stderr) + + def test_main_records_xbox_result_without_changing_it(self): + launch = lambda command, env: 23 + with tempfile.TemporaryDirectory(prefix="xbox-exit-diagnostics-") as directory, \ + mock.patch.dict(os.environ, { + "HOME": directory, + "PATH": os.defpath, + "STEAM_COMPAT_DATA_PATH": "/compatdata/42", + "DROIDDECK_ENHANCED_DIAGNOSTICS": "1", + }, clear=True), \ + mock.patch("sys.argv", ["droiddeck-game-env", "/proton", "waitforexitandrun", "game.exe"]), \ + mock.patch("runpy.run_path", return_value={"launch": launch}), \ + contextlib.redirect_stderr(io.StringIO()) as said: + status = MODULE["main"]() + self.assertEqual(status, 23) + self.assertNotIn("event=game_start", said.getvalue()) + self.assertIn( + "event=game_exit app_id=42 raw_status=23 normalized_status=23 wrapper_status=23 signal=0 source=xbox", + said.getvalue(), + ) + + def test_main_preserves_negative_xbox_result_and_reports_wrapper_status(self): + launch = lambda command, env: -signal.SIGTERM + with tempfile.TemporaryDirectory(prefix="xbox-signal-diagnostics-") as directory, \ + mock.patch.dict(os.environ, { + "HOME": directory, + "PATH": os.defpath, + "STEAM_COMPAT_DATA_PATH": "/compatdata/42", + "DROIDDECK_ENHANCED_DIAGNOSTICS": "1", + }, clear=True), \ + mock.patch("sys.argv", ["droiddeck-game-env", "/proton", "waitforexitandrun", "game.exe"]), \ + mock.patch("runpy.run_path", return_value={"launch": launch}), \ + contextlib.redirect_stderr(io.StringIO()) as said: + status = MODULE["main"]() + self.assertEqual(status, -signal.SIGTERM) + self.assertIn( + "event=game_exit app_id=42 raw_status=-15 normalized_status=143 wrapper_status=241 signal=15 source=xbox", + said.getvalue(), + ) + + +if __name__ == "__main__": + unittest.main() diff --git a/tools/tests/test_gamescope_diagnostics.py b/tools/tests/test_gamescope_diagnostics.py new file mode 100644 index 0000000000..80f639b0d0 --- /dev/null +++ b/tools/tests/test_gamescope_diagnostics.py @@ -0,0 +1,133 @@ +import os +from pathlib import Path +import re +import shutil +import subprocess +import tempfile +import unittest + + +ROOT = Path(__file__).resolve().parents[2] +PATCH = ROOT / "tools/gamescope/patches/0900-enhanced-frame-diagnostics.patch" + + +def added_file(patch, name): + lines = patch.read_text().splitlines() + marker = f"diff --git a/{name} b/{name}" + start = lines.index(marker) + output = [] + in_hunk = False + for line in lines[start + 1:]: + if line.startswith("diff --git "): + break + if line.startswith("@@"): + in_hunk = True + elif in_hunk and line.startswith("+") and not line.startswith("+++"): + output.append(line[1:]) + return "\n".join(output) + "\n" + + +class GamescopeDiagnosticsTest(unittest.TestCase): + def test_patch_covers_each_frame_boundary_without_payload_logging(self): + text = PATCH.read_text() + for path in ("src/wlserver.cpp", "src/steamcompmgr.cpp", "src/Backends/WaylandBackend.cpp"): + self.assertIn(f"diff --git a/{path} b/{path}", text) + self.assertIn("diff --git a/src/main.cpp b/src/main.cpp", text) + self.assertIn("droiddeck::frame_trace::Start();", text) + self.assertIn("droiddeck::frame_trace::Tick();", text) + self.assertIn("pTraceFocus->focusWindow == w", text) + self.assertNotIn("GetFocusForWindow( w ) != nullptr", text) + for event in ( + "X11Damage", "X11DamageCurrent", "X11DamageOther", "SurfaceCommit", + "SurfaceCommitBuffer", "SurfaceCommitNoBuffer", "CommitDequeued", + "CommitDequeuedCurrent", "CommitDequeuedOther", "ImportSucceeded", + "ImportSucceededCurrent", "ImportSucceededOther", "ImportFailed", + "ImportFailedCurrent", "ImportFailedOther", "FenceReady", "FenceWaited", + "CommitDone", "CommitDoneCurrent", "CommitDoneOther", "BaseLatched", + "BaseLatchedCurrent", "BaseLatchedOther", + "OutputPresent", "OutputAttach", "OutputDetach", + "OutputCommit", "OutputRelease", + ): + self.assertIn(f"Event::{event}", text) + header = added_file(PATCH, "src/droiddeck_frame_trace.hpp") + self.assertIn('std::getenv( "DROIDDECK_ENHANCED_DIAGNOSTICS" )', header) + self.assertIn("DROIDDECK_FRAME_TRACE_FAST_INTERVAL_MS 2000", header) + self.assertIn("DROIDDECK_FRAME_TRACE_SLOW_INTERVAL_MS 15000", header) + self.assertIn("DROIDDECK_FRAME_TRACE_DURATION_MS 86400000", header) + self.assertNotRegex(header, re.compile(r"title|pixel|address|argv", re.I)) + + def test_collector_is_default_off_bounded_and_thread_safe(self): + compiler = shutil.which(os.environ.get("CXX", "c++")) + if not compiler: + self.skipTest("a C++ compiler is required") + with tempfile.TemporaryDirectory(prefix="gamescope-frame-trace-") as directory: + work = Path(directory) + (work / "droiddeck_frame_trace.hpp").write_text( + added_file(PATCH, "src/droiddeck_frame_trace.hpp")) + (work / "trace.cpp").write_text(r''' +#include "droiddeck_frame_trace.hpp" +#include +#include +#include +int main() { + droiddeck::frame_trace::Start(); + std::vector threads; + for (int i = 0; i < 4; ++i) + threads.emplace_back([] { for (int n = 0; n < 1000; ++n) + droiddeck::frame_trace::RecordWindow( + droiddeck::frame_trace::Event::X11Damage, + droiddeck::frame_trace::Event::X11DamageCurrent, + droiddeck::frame_trace::Event::X11DamageOther, + false); }); + for (auto &thread : threads) thread.join(); + std::this_thread::sleep_for(std::chrono::milliseconds(60)); + droiddeck::frame_trace::Tick(); + std::this_thread::sleep_for(std::chrono::milliseconds(70)); + droiddeck::frame_trace::Tick(); + droiddeck::frame_trace::Record(droiddeck::frame_trace::Event::SurfaceCommit); + droiddeck::frame_trace::RecordWindow( + droiddeck::frame_trace::Event::ImportSucceeded, + droiddeck::frame_trace::Event::ImportSucceededCurrent, + droiddeck::frame_trace::Event::ImportSucceededOther, + true); + std::this_thread::sleep_for(std::chrono::milliseconds(70)); + droiddeck::frame_trace::Tick(); + std::this_thread::sleep_for(std::chrono::milliseconds(120)); + droiddeck::frame_trace::Tick(); + droiddeck::frame_trace::Record(droiddeck::frame_trace::Event::OutputPresent); + droiddeck::frame_trace::Tick(); +} +''') + program = work / "trace" + built = subprocess.run([ + compiler, "-std=c++20", "-Wall", "-Wextra", "-Werror", "-pthread", + "-DDROIDDECK_FRAME_TRACE_FAST_INTERVAL_MS=50", + "-DDROIDDECK_FRAME_TRACE_SLOW_INTERVAL_MS=60", + "-DDROIDDECK_FRAME_TRACE_FAST_DURATION_MS=100", + "-DDROIDDECK_FRAME_TRACE_DURATION_MS=300", + str(work / "trace.cpp"), "-o", str(program), + ], capture_output=True, text=True) + self.assertEqual(0, built.returncode, built.stdout + built.stderr) + quiet = subprocess.run([str(program)], capture_output=True, text=True, timeout=10) + self.assertEqual(0, quiet.returncode, quiet.stdout + quiet.stderr) + self.assertEqual("", quiet.stderr) + env = os.environ.copy() + env["DROIDDECK_ENHANCED_DIAGNOSTICS"] = "1" + traced = subprocess.run([str(program)], env=env, capture_output=True, text=True, timeout=10) + self.assertEqual(0, traced.returncode, traced.stdout + traced.stderr) + self.assertEqual(1, traced.stderr.count("schema=1")) + summaries = [line for line in traced.stderr.splitlines() if "t_ms=" in line] + self.assertIn("t_ms=0 x11_damage=0", summaries[0]) + self.assertTrue(any("x11_damage=4000" in line and "x11_damage_current=0" in line and + "x11_damage_other=4000" in line and "surface_commit=0" in line + for line in summaries[1:])) + self.assertTrue(any("surface_commit=1" in line for line in summaries[1:])) + self.assertTrue(any("import_ok=1" in line and "import_ok_current=1" in line and + "import_ok_other=0" in line for line in summaries[1:])) + self.assertIn("t_ms=300", summaries[-1]) + self.assertIn("output_present=0", summaries[-1]) + self.assertLessEqual(len(summaries), 5) + + +if __name__ == "__main__": + unittest.main() diff --git a/tools/tests/test_steam_exit_status.py b/tools/tests/test_steam_exit_status.py index e66341febe..8cfc218ab3 100644 --- a/tools/tests/test_steam_exit_status.py +++ b/tools/tests/test_steam_exit_status.py @@ -11,7 +11,7 @@ SESSION = Path(__file__).resolve().parents[1] / 'linuxfs/overlay/usr/local/bin/d class SteamExitStatusTest(unittest.TestCase): def run_session(self, child_status, compositor_status=0, report=True, report_value=None, - stale_status=None): + stale_status=None, diagnostics=False, output=False): source = SESSION.read_text() function = re.search(r'^run_gamescope\(\) \(\n.*?^\)\n', source, re.M | re.S) self.assertIsNotNone(function) @@ -31,6 +31,7 @@ class SteamExitStatusTest(unittest.TestCase): child.chmod(0o755) env = dict(os.environ, PATH=str(root) + os.pathsep + os.environ['PATH'], XDG_RUNTIME_DIR=str(root)) + env['DROIDDECK_ENHANCED_DIAGNOSTICS'] = '1' if diagnostics else '0' result = subprocess.run(['bash', '-c', function.group() + '\nrun_gamescope "$@"', 'session', str(child), str(child_status), str(report_value) if report_value is not None else ''], env=env, @@ -38,7 +39,7 @@ class SteamExitStatusTest(unittest.TestCase): self.assertEqual(list(root.glob('droiddeck-steam-exit.??????')), []) if stale_status is not None: self.assertEqual(stale_file.read_text(), str(stale_status) + '\n') - return result.returncode + return result if output else result.returncode def test_steam_crash_survives_successful_compositor_shutdown(self): self.assertEqual(self.run_session(139), 139) @@ -64,6 +65,21 @@ class SteamExitStatusTest(unittest.TestCase): def test_stale_marker_does_not_affect_a_new_launch(self): self.assertEqual(self.run_session(0, report=False, stale_status=139), 0) + def test_diagnostics_preserve_separate_steam_and_compositor_statuses(self): + result = self.run_session(139, diagnostics=True, output=True) + self.assertEqual(result.returncode, 139) + self.assertIn('event=session_exit compositor_status=0 steam_status=139', result.stdout) + + def test_diagnostics_report_an_unavailable_child_status(self): + result = self.run_session(0, compositor_status=1, report=False, diagnostics=True, output=True) + self.assertEqual(result.returncode, 1) + self.assertIn('event=session_exit compositor_status=1 steam_status=unavailable', result.stdout) + + def test_diagnostics_are_disabled_by_default(self): + result = self.run_session(0, output=True) + self.assertEqual(result.returncode, 0) + self.assertNotIn('DROIDDECK_DIAGNOSTICS', result.stdout) + if __name__ == '__main__': unittest.main()