mirror of
https://github.com/Droid-Deck/DroidDeck.git
synced 2026-11-19 12:56:06 +00:00
fix: let the device sleep while a session is suspended (#1220)
* fix: stop the DirectAudio output while the sink is suspended * fix: verify every session thread before reporting suspension * fix: freeze PRoot first and stop each guest thread on suspend --------- Co-authored-by: Detinator10 <8469261+Detinator10@users.noreply.github.com>
This commit is contained in:
1 parent
8ea48dc039
commit
4f8a7c5596
5 files changed
+611
-111
No files matched your search
@@ -1,5 +1,8 @@
|
||||
#include <errno.h>
|
||||
#include <jni.h>
|
||||
#include <stdatomic.h>
|
||||
#include <sys/syscall.h>
|
||||
#include <unistd.h>
|
||||
|
||||
JNIEXPORT void JNICALL
|
||||
Java_com_droiddeck_launcher_input_FakeInputWriter_nativeStoreFence(JNIEnv *env, jclass clazz) {
|
||||
@@ -7,3 +10,10 @@ Java_com_droiddeck_launcher_input_FakeInputWriter_nativeStoreFence(JNIEnv *env,
|
||||
(void)clazz;
|
||||
atomic_thread_fence(memory_order_release);
|
||||
}
|
||||
|
||||
JNIEXPORT jint JNICALL
|
||||
Java_com_droiddeck_launcher_session_ThreadSignals_tgkill(JNIEnv *env, jclass clazz, jint tgid, jint tid, jint signal) {
|
||||
(void)env;
|
||||
(void)clazz;
|
||||
return syscall(SYS_tgkill, tgid, tid, signal) == 0 ? 0 : errno;
|
||||
}
|
||||
@@ -2,14 +2,22 @@ package com.droiddeck.launcher.session
|
||||
|
||||
import android.os.Process
|
||||
import java.io.File
|
||||
import java.io.IOException
|
||||
import java.util.concurrent.ExecutorService
|
||||
import java.util.concurrent.Executors
|
||||
import java.util.concurrent.RejectedExecutionException
|
||||
|
||||
internal class SessionSuspendController(
|
||||
private val sessionRoot: () -> Int,
|
||||
private val helperRoots: () -> List<Int>,
|
||||
private val suspendAudio: () -> Unit,
|
||||
private val resumeAudio: () -> Unit,
|
||||
private val procRoot: File = File("/proc"),
|
||||
private val signal: (Int, Int) -> Unit = Process::sendSignal,
|
||||
private val threadSignal: (Int, Int, Int) -> Unit = { pid, tid, signal -> ThreadSignals.tgkill(pid, tid, signal) },
|
||||
private val sleep: (Long) -> Unit = Thread::sleep,
|
||||
private val nowMillis: () -> Long = { System.nanoTime() / 1_000_000 },
|
||||
private val executor: ExecutorService = Executors.newSingleThreadExecutor(),
|
||||
) {
|
||||
private enum class Role { SESSION_ROOT, SESSION_CHILD, HELPER_ROOT, HELPER_CHILD }
|
||||
|
||||
@@ -24,96 +32,95 @@ internal class SessionSuspendController(
|
||||
val parent: Int,
|
||||
val started: Long,
|
||||
val state: Char,
|
||||
val tracer: Int,
|
||||
)
|
||||
|
||||
private val executor: ExecutorService = Executors.newSingleThreadExecutor()
|
||||
private data class TaskIdentity(val process: ProcessRecord, val tid: Int, val started: Long)
|
||||
|
||||
@Volatile private var closing = false
|
||||
private var frozen = emptyList<ProcessRecord>()
|
||||
|
||||
fun freeze(completion: (Boolean) -> Unit) {
|
||||
submit {
|
||||
if (closing) {
|
||||
completion(false)
|
||||
return@submit
|
||||
}
|
||||
if (frozen.isNotEmpty()) {
|
||||
val fullyFrozen = frozen.any { it.role == Role.SESSION_ROOT } && frozen.all(::isStoppedOrGone)
|
||||
if (!fullyFrozen && restore(frozen)) frozen = emptyList()
|
||||
completion(fullyFrozen)
|
||||
return@submit
|
||||
}
|
||||
val records = LinkedHashMap<Pair<Int, Long>, ProcessRecord>()
|
||||
val root = sessionRoot()
|
||||
if (root <= 1) {
|
||||
completion(false)
|
||||
return@submit
|
||||
}
|
||||
runAudio(suspendAudio)
|
||||
val helpers = helperRoots().filter { it > 1 && it != root }.distinct()
|
||||
var stablePasses = 0
|
||||
submit({
|
||||
val records = frozen.associateByTo(LinkedHashMap()) { it.pid to it.started }
|
||||
var complete = false
|
||||
repeat(10) { pass ->
|
||||
if (closing) {
|
||||
restore(records.values.toList())
|
||||
runAudio(resumeAudio)
|
||||
completion(false)
|
||||
return@submit
|
||||
var interrupted = false
|
||||
try {
|
||||
val root = records.values.firstOrNull { it.role == Role.SESSION_ROOT }
|
||||
?: readProcess(sessionRoot())?.takeIf { it.pid > 1 }?.let {
|
||||
ProcessRecord(it.pid, it.started, Role.SESSION_ROOT)
|
||||
} ?: throw IOException("Session root is unavailable")
|
||||
records[root.pid to root.started] = root
|
||||
runAudio(suspendAudio)
|
||||
val helpers = helperRoots().filter { it > 1 && it != root.pid }.distinct()
|
||||
for (helper in helpers) {
|
||||
if (records.values.any { it.pid == helper && it.role == Role.HELPER_ROOT }) continue
|
||||
readProcess(helper)?.let {
|
||||
records[it.pid to it.started] = ProcessRecord(it.pid, it.started, Role.HELPER_ROOT)
|
||||
}
|
||||
}
|
||||
val includeRoots = pass >= 2
|
||||
addSnapshot(records, root, helpers, includeRoots)
|
||||
stop(records.values.toList(), includeRoots)
|
||||
Thread.sleep(if (pass == 0) 70L else 35L)
|
||||
val rootCaptured = records.values.any { it.role == Role.SESSION_ROOT }
|
||||
if (rootCaptured && records.isNotEmpty() && records.values.all(::isStoppedOrGone)) {
|
||||
stablePasses++
|
||||
if (stablePasses >= 2) complete = true
|
||||
} else {
|
||||
stablePasses = 0
|
||||
val deadline = nowMillis() + FREEZE_TIMEOUT_MS
|
||||
var previous: Map<TaskIdentity, Long>? = null
|
||||
for (pass in 0 until FREEZE_MAX_PASSES) {
|
||||
if (closing || nowMillis() >= deadline) break
|
||||
try {
|
||||
if (readProcess(root.pid)?.started != root.started) break
|
||||
addSnapshot(records, root.pid, helpers)
|
||||
if (readProcess(root.pid)?.started != root.started) break
|
||||
stop(records.values.toList())
|
||||
sleep(if (pass == 0) 70L else 35L)
|
||||
if (closing || nowMillis() >= deadline) break
|
||||
val current = stoppedSnapshot(records.values.toList(), root)
|
||||
if (current != null && current == previous) {
|
||||
complete = true
|
||||
break
|
||||
}
|
||||
previous = current
|
||||
} catch (_: IOException) {
|
||||
previous = null
|
||||
sleep(35L)
|
||||
}
|
||||
}
|
||||
}
|
||||
if (complete) {
|
||||
} catch (_: InterruptedException) {
|
||||
interrupted = true
|
||||
Thread.interrupted()
|
||||
} catch (_: Exception) {
|
||||
} finally {
|
||||
frozen = records.values.toList()
|
||||
completion(true)
|
||||
} else {
|
||||
val restored = restore(records.values.toList())
|
||||
runAudio(resumeAudio)
|
||||
if (!restored) frozen = records.values.toList()
|
||||
completion(false)
|
||||
if (!complete) {
|
||||
if (restoreSafely(frozen)) frozen = emptyList()
|
||||
runAudio(resumeAudio)
|
||||
}
|
||||
if (interrupted) Thread.currentThread().interrupt()
|
||||
}
|
||||
}
|
||||
completion(complete)
|
||||
}, { completion(false) })
|
||||
}
|
||||
|
||||
fun resume(completion: (Boolean) -> Unit) {
|
||||
submit {
|
||||
submit({
|
||||
val records = frozen
|
||||
runAudio(resumeAudio)
|
||||
val resumed = restore(records)
|
||||
val resumed = restoreSafely(records)
|
||||
if (resumed) frozen = emptyList()
|
||||
completion(resumed)
|
||||
}
|
||||
}, { completion(false) })
|
||||
}
|
||||
|
||||
fun closeAndResume(completion: () -> Unit) {
|
||||
closing = true
|
||||
submit {
|
||||
restore(frozen)
|
||||
frozen = emptyList()
|
||||
submit({
|
||||
if (restoreSafely(frozen)) frozen = emptyList()
|
||||
completion()
|
||||
executor.shutdown()
|
||||
}
|
||||
}, completion)
|
||||
}
|
||||
|
||||
private fun submit(task: () -> Unit) {
|
||||
private fun submit(task: () -> Unit, rejected: () -> Unit) {
|
||||
try {
|
||||
executor.execute {
|
||||
try {
|
||||
task()
|
||||
} catch (_: InterruptedException) {
|
||||
Thread.currentThread().interrupt()
|
||||
}
|
||||
}
|
||||
} catch (_: RuntimeException) {
|
||||
task()
|
||||
executor.execute(task)
|
||||
} catch (_: RejectedExecutionException) {
|
||||
rejected()
|
||||
}
|
||||
}
|
||||
|
||||
@@ -128,23 +135,25 @@ internal class SessionSuspendController(
|
||||
records: MutableMap<Pair<Int, Long>, ProcessRecord>,
|
||||
root: Int,
|
||||
helpers: List<Int>,
|
||||
includeRoots: Boolean,
|
||||
) {
|
||||
val processes = readProcesses()
|
||||
val byPid = processes.associateBy { it.pid }
|
||||
for (process in descendants(root, processes, byPid)) {
|
||||
records[process.pid to process.started] = ProcessRecord(process.pid, process.started, Role.SESSION_CHILD)
|
||||
val rootRecord = records.values.first { it.role == Role.SESSION_ROOT }
|
||||
if (byPid[root]?.started != rootRecord.started) throw IOException("Session root exited or changed")
|
||||
val liveHelpers = helpers.filter { pid ->
|
||||
records.values.any { it.pid == pid && it.role == Role.HELPER_ROOT && it.started == byPid[pid]?.started }
|
||||
}
|
||||
for (helper in helpers) {
|
||||
for (process in descendants(root, processes, byPid) + processes.filter { it.tracer == root }) {
|
||||
records.putIfAbsent(process.pid to process.started, ProcessRecord(process.pid, process.started, Role.SESSION_CHILD))
|
||||
}
|
||||
for (helper in liveHelpers) {
|
||||
for (process in descendants(helper, processes, byPid)) {
|
||||
records[process.pid to process.started] = ProcessRecord(process.pid, process.started, Role.HELPER_CHILD)
|
||||
records.putIfAbsent(process.pid to process.started, ProcessRecord(process.pid, process.started, Role.HELPER_CHILD))
|
||||
}
|
||||
}
|
||||
if (includeRoots) {
|
||||
byPid[root]?.let { records[it.pid to it.started] = ProcessRecord(it.pid, it.started, Role.SESSION_ROOT) }
|
||||
for (helper in helpers) {
|
||||
byPid[helper]?.let { records[it.pid to it.started] = ProcessRecord(it.pid, it.started, Role.HELPER_ROOT) }
|
||||
}
|
||||
byPid[root]?.let { records[it.pid to it.started] = ProcessRecord(it.pid, it.started, Role.SESSION_ROOT) }
|
||||
for (helper in liveHelpers) {
|
||||
byPid[helper]?.let { records[it.pid to it.started] = ProcessRecord(it.pid, it.started, Role.HELPER_ROOT) }
|
||||
}
|
||||
}
|
||||
|
||||
@@ -168,36 +177,84 @@ internal class SessionSuspendController(
|
||||
}
|
||||
|
||||
private fun readProcesses(): List<ProcessInfo> =
|
||||
File("/proc").listFiles().orEmpty().mapNotNull { entry ->
|
||||
(procRoot.listFiles() ?: throw IOException("Cannot enumerate processes")).mapNotNull { entry ->
|
||||
val pid = entry.name.toIntOrNull() ?: return@mapNotNull null
|
||||
readProcess(pid)
|
||||
try { readProcess(pid) } catch (_: IOException) { null }
|
||||
}
|
||||
|
||||
private fun readProcess(pid: Int): ProcessInfo? {
|
||||
val stat = try {
|
||||
File("/proc/$pid/stat").readText()
|
||||
} catch (_: Exception) {
|
||||
return null
|
||||
}
|
||||
val close = stat.lastIndexOf(')')
|
||||
if (close < 0 || close + 2 >= stat.length) return null
|
||||
val fields = stat.substring(close + 2).trim().split(Regex("\\s+"))
|
||||
if (fields.size < 20) return null
|
||||
return try {
|
||||
ProcessInfo(pid, fields[1].toInt(), fields[19].toLong(), fields[0].first())
|
||||
} catch (_: NumberFormatException) {
|
||||
null
|
||||
val base = File(procRoot, pid.toString())
|
||||
try {
|
||||
val fields = readStat(File(base, "stat"))
|
||||
val tracer = File(base, "status").useLines { lines ->
|
||||
lines.firstOrNull { it.startsWith("TracerPid:") }?.substringAfter(':')?.trim()?.toIntOrNull() ?: 0
|
||||
}
|
||||
return ProcessInfo(pid, fields[1].toInt(), fields[19].toLong(), fields[0].first(), tracer)
|
||||
} catch (error: IOException) {
|
||||
if (procRoot.list()?.contains(pid.toString()) == false) return null
|
||||
throw error
|
||||
}
|
||||
}
|
||||
|
||||
private fun stop(records: List<ProcessRecord>, includeRoots: Boolean) {
|
||||
val descendants = records.filter { it.role == Role.SESSION_CHILD || it.role == Role.HELPER_CHILD }
|
||||
val session = records.filter { it.role == Role.SESSION_ROOT }
|
||||
val helpers = records.filter { it.role == Role.HELPER_ROOT }
|
||||
for (record in descendants) send(record, SIGSTOP)
|
||||
if (includeRoots) {
|
||||
for (record in session) send(record, SIGSTOP)
|
||||
for (record in helpers) send(record, SIGSTOP)
|
||||
private fun readStat(file: File): List<String> {
|
||||
val stat = file.readText()
|
||||
val close = stat.lastIndexOf(')')
|
||||
if (close < 0 || close + 2 >= stat.length) throw IOException("Invalid process stat: $file")
|
||||
val fields = stat.substring(close + 2).trim().split(Regex("\\s+"))
|
||||
if (fields.size < 20) throw IOException("Incomplete process stat: $file")
|
||||
return fields
|
||||
}
|
||||
|
||||
private fun stoppedSnapshot(records: List<ProcessRecord>, root: ProcessRecord): Map<TaskIdentity, Long>? {
|
||||
// PRoot can leave the leader stopped while native worker threads keep running.
|
||||
val tasks = LinkedHashMap<TaskIdentity, Long>()
|
||||
var stopped = true
|
||||
for (record in records) {
|
||||
val current = readProcess(record.pid)
|
||||
if (current == null || current.started != record.started) {
|
||||
if (record == root) throw IOException("Session root exited or changed")
|
||||
continue
|
||||
}
|
||||
val entries = File(procRoot, "${record.pid}/task").listFiles()
|
||||
?: throw IOException("Cannot enumerate threads: ${record.pid}")
|
||||
if (entries.none { it.name.toIntOrNull() != null }) throw IOException("Empty thread inventory: ${record.pid}")
|
||||
var liveRoot = false
|
||||
for (entry in entries) {
|
||||
val tid = entry.name.toIntOrNull() ?: continue
|
||||
val fields = readStat(File(entry, "stat"))
|
||||
val state = fields[0].first()
|
||||
if (state != 'Z' && state != 'X') liveRoot = true
|
||||
if (state != 'T' && state != 't' && state != 'Z' && state != 'X') stopped = false
|
||||
tasks[TaskIdentity(record, tid, fields[19].toLong())] = fields[11].toLong() + fields[12].toLong()
|
||||
}
|
||||
if (record == root && !liveRoot) throw IOException("Session root has no live threads")
|
||||
if (readProcess(record.pid)?.started != record.started) throw IOException("Process changed during inspection")
|
||||
}
|
||||
return tasks.takeIf { stopped && it.isNotEmpty() }
|
||||
}
|
||||
|
||||
// PRoot traces every guest. A stop sent while it runs becomes a group stop that it restarts
|
||||
// thread by thread; once it is stopped, each thread that takes a SIGSTOP stays parked in its
|
||||
// signal-delivery stop. So the roots stop first and every guest thread gets its own SIGSTOP.
|
||||
private fun stop(records: List<ProcessRecord>) {
|
||||
for (record in records.filter { it.role == Role.SESSION_ROOT }) send(record, SIGSTOP)
|
||||
for (record in records.filter { it.role == Role.HELPER_ROOT }) send(record, SIGSTOP)
|
||||
for (record in records.filter { it.role == Role.SESSION_CHILD || it.role == Role.HELPER_CHILD }) {
|
||||
stopThreads(record)
|
||||
}
|
||||
}
|
||||
|
||||
private fun stopThreads(record: ProcessRecord) {
|
||||
val current = try { readProcess(record.pid) } catch (_: Exception) { return }
|
||||
if (current == null || current.started != record.started) return
|
||||
for (entry in File(procRoot, "${record.pid}/task").listFiles().orEmpty()) {
|
||||
val tid = entry.name.toIntOrNull() ?: continue
|
||||
val state = try { readStat(File(entry, "stat"))[0].first() } catch (_: IOException) { continue }
|
||||
if (state == 'T' || state == 't' || state == 'Z' || state == 'X') continue
|
||||
try {
|
||||
threadSignal(record.pid, tid, SIGSTOP)
|
||||
} catch (_: Throwable) {
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -213,7 +270,7 @@ internal class SessionSuspendController(
|
||||
for (record in ordered) send(record, SIGCONT)
|
||||
val waiting = ordered.toMutableList()
|
||||
repeat(RESTORE_CHECKS) { check ->
|
||||
Thread.sleep(25L)
|
||||
sleep(25L)
|
||||
waiting.removeAll { isRunningOrGone(it) }
|
||||
if (waiting.isEmpty()) return true
|
||||
if (check % 8 == 7) for (record in waiting) send(record, SIGCONT)
|
||||
@@ -221,30 +278,40 @@ internal class SessionSuspendController(
|
||||
return false
|
||||
}
|
||||
|
||||
private fun restoreSafely(records: List<ProcessRecord>): Boolean = try {
|
||||
restore(records)
|
||||
} catch (_: InterruptedException) {
|
||||
Thread.currentThread().interrupt()
|
||||
false
|
||||
} catch (_: Exception) {
|
||||
false
|
||||
}
|
||||
|
||||
private fun send(record: ProcessRecord, signal: Int) {
|
||||
val current = readProcess(record.pid) ?: return
|
||||
if (current.started != record.started) return
|
||||
val current = try { readProcess(record.pid) } catch (_: Exception) { return }
|
||||
if (current == null || current.started != record.started) return
|
||||
try {
|
||||
Process.sendSignal(record.pid, signal)
|
||||
this.signal(record.pid, signal)
|
||||
} catch (_: Throwable) {
|
||||
}
|
||||
}
|
||||
|
||||
private fun isStoppedOrGone(record: ProcessRecord): Boolean {
|
||||
val current = readProcess(record.pid) ?: return true
|
||||
if (current.started != record.started) return true
|
||||
return current.state == 'T' || current.state == 't' || current.state == 'Z' || current.state == 'X'
|
||||
}
|
||||
|
||||
private fun isRunningOrGone(record: ProcessRecord): Boolean {
|
||||
val current = readProcess(record.pid) ?: return true
|
||||
if (current.started != record.started) return true
|
||||
return current.state != 'T' && current.state != 't'
|
||||
val current = try { readProcess(record.pid) } catch (_: Exception) { return false }
|
||||
if (current == null || current.started != record.started) return true
|
||||
if (current.state == 'T' || current.state == 't') return false
|
||||
// A traced worker in 't' is usually PRoot handling a system call; 'T' is a job-control stop.
|
||||
return File(procRoot, "${record.pid}/task").listFiles().orEmpty().none { entry ->
|
||||
entry.name.toIntOrNull() != null &&
|
||||
try { readStat(File(entry, "stat"))[0].first() == 'T' } catch (_: IOException) { false }
|
||||
}
|
||||
}
|
||||
|
||||
private companion object {
|
||||
const val SIGSTOP = 19
|
||||
const val SIGCONT = 18
|
||||
const val RESTORE_CHECKS = 80
|
||||
const val FREEZE_TIMEOUT_MS = 8_000L
|
||||
const val FREEZE_MAX_PASSES = 256
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,9 @@
|
||||
package com.droiddeck.launcher.session
|
||||
|
||||
internal object ThreadSignals {
|
||||
init {
|
||||
System.loadLibrary("sdnative")
|
||||
}
|
||||
|
||||
@JvmStatic external fun tgkill(tgid: Int, tid: Int, signal: Int): Int
|
||||
}
|
||||
@@ -0,0 +1,379 @@
|
||||
package com.droiddeck.launcher.session
|
||||
|
||||
import java.io.File
|
||||
import java.util.concurrent.AbstractExecutorService
|
||||
import java.util.concurrent.RejectedExecutionException
|
||||
import java.util.concurrent.TimeUnit
|
||||
import org.junit.Assert.assertEquals
|
||||
import org.junit.Assert.assertFalse
|
||||
import org.junit.Assert.assertTrue
|
||||
import org.junit.Rule
|
||||
import org.junit.Test
|
||||
import org.junit.rules.TemporaryFolder
|
||||
|
||||
class SessionSuspendControllerTest {
|
||||
@get:Rule val temporary = TemporaryFolder()
|
||||
|
||||
@Test fun everyWorkerThreadIsStoppedAfterTheRoot() {
|
||||
for (count in listOf(17, 68)) {
|
||||
val fixture = fixture(count)
|
||||
fixture.controller.freeze { assertTrue(it) }
|
||||
assertTrue(fixture.game.threads.all { it.state == 't' })
|
||||
assertTrue(fixture.signals.count { it.pid == GAME && it.signal == STOP } >= count)
|
||||
assertEquals(ROOT, fixture.signals.first { it.signal == STOP }.pid)
|
||||
assertTrue(fixture.now < 1000)
|
||||
assertEquals(1, fixture.audioSuspends)
|
||||
}
|
||||
}
|
||||
|
||||
@Test fun cpuMustBeStableAcrossTwoCompleteSnapshots() {
|
||||
val fixture = fixture(17)
|
||||
var changes = 0
|
||||
fixture.afterSleep = {
|
||||
if (fixture.game.threads.all { it.state == 't' } && changes < 3) {
|
||||
fixture.game.threads.last().cpu++
|
||||
changes++
|
||||
}
|
||||
}
|
||||
fixture.controller.freeze { assertTrue(it) }
|
||||
assertEquals(3, changes)
|
||||
assertTrue(fixture.signals.count { it.pid == GAME && it.signal == STOP } >= 17)
|
||||
}
|
||||
|
||||
@Test fun reusedTidAndNewThreadMustJoinTheStableInventory() {
|
||||
val fixture = fixture(17)
|
||||
var changed = false
|
||||
fixture.afterSleep = {
|
||||
if (!changed && fixture.game.threads.all { it.state == 't' }) {
|
||||
changed = true
|
||||
fixture.game.threads.last().apply { started++; state = 'S'; cpu = 0 }
|
||||
fixture.game.threads += Task(500, 9000, 'S')
|
||||
}
|
||||
}
|
||||
fixture.controller.freeze { assertTrue(it) }
|
||||
assertTrue(changed)
|
||||
assertTrue(fixture.game.threads.all { it.state == 't' })
|
||||
assertTrue(fixture.signals.count { it.pid == GAME && it.signal == STOP } >= 19)
|
||||
}
|
||||
|
||||
@Test fun zombieLeaderDoesNotHideRunningWorkers() {
|
||||
val fixture = fixture(17)
|
||||
fixture.game.threads.first().state = 'Z'
|
||||
fixture.sync()
|
||||
fixture.controller.freeze { assertTrue(it) }
|
||||
assertEquals('Z', fixture.game.threads.first().state)
|
||||
assertTrue(fixture.game.threads.drop(1).all { it.state == 't' })
|
||||
assertTrue(fixture.signals.count { it.pid == GAME && it.signal == STOP } >= 16)
|
||||
}
|
||||
|
||||
@Test fun lateReparentedTraceeIsDiscoveredAndResumed() {
|
||||
val fixture = fixture(17)
|
||||
val late = Group(600, 1, ROOT, mutableListOf(Task(600, 6000, 'S')))
|
||||
fixture.afterSleep = {
|
||||
if (fixture.root.threads.first().state == 'T' && late !in fixture.groups) fixture.groups += late
|
||||
}
|
||||
fixture.controller.freeze { assertTrue(it) }
|
||||
assertEquals('t', late.threads.first().state)
|
||||
fixture.controller.resume { assertTrue(it) }
|
||||
assertEquals('S', late.threads.first().state)
|
||||
}
|
||||
|
||||
@Test fun descendantHelperKeepsRootStopAndResumeOrdering() {
|
||||
val fixture = fixture(17)
|
||||
val helper = Group(700, ROOT, 0, mutableListOf(Task(700, 7000, 'S')))
|
||||
fixture.groups += helper
|
||||
fixture.helpers += helper.pid
|
||||
fixture.sync()
|
||||
fixture.controller.freeze { assertTrue(it) }
|
||||
val stops = fixture.signals.filter { it.signal == STOP }
|
||||
assertTrue(stops.indexOfFirst { it.pid == ROOT } < stops.indexOfFirst { it.pid == helper.pid })
|
||||
val before = fixture.signals.size
|
||||
fixture.controller.resume { assertTrue(it) }
|
||||
assertEquals(listOf(ROOT, helper.pid, GAME), fixture.signals.drop(before).take(3).map { it.pid })
|
||||
}
|
||||
|
||||
@Test fun retainedHelperDoesNotAdoptAReusedPidOnRefreeze() {
|
||||
val fixture = fixture(17)
|
||||
val helper = Group(700, 9000, 0, mutableListOf(Task(700, 7000, 'S')))
|
||||
fixture.groups += helper
|
||||
fixture.helpers += helper.pid
|
||||
fixture.sync()
|
||||
fixture.controller.freeze { assertTrue(it) }
|
||||
fixture.blockGameContinue = true
|
||||
fixture.controller.resume { assertFalse(it) }
|
||||
helper.threads.first().apply { started++; state = 'S' }
|
||||
fixture.sync()
|
||||
val before = fixture.signals.size
|
||||
fixture.controller.freeze { assertTrue(it) }
|
||||
assertFalse(fixture.signals.drop(before).any { it.pid == helper.pid })
|
||||
}
|
||||
|
||||
@Test fun timeoutRollsBackAllKnownProcessesAndAudio() {
|
||||
val fixture = fixture(17)
|
||||
fixture.neverStop = true
|
||||
fixture.controller.freeze { assertFalse(it) }
|
||||
assertTrue(fixture.now <= 8100)
|
||||
assertEquals(ROOT, fixture.signals.first { it.signal == CONT }.pid)
|
||||
assertTrue(fixture.game.threads.all { it.state == 'S' })
|
||||
assertEquals(1, fixture.audioResumes)
|
||||
}
|
||||
|
||||
@Test fun missingKnownStatCannotBeMistakenForAnExitedProcess() {
|
||||
val fixture = fixture(17)
|
||||
fixture.afterSleep = {
|
||||
if (fixture.root.threads.first().state == 'T') fixture.missingGameStat = true
|
||||
}
|
||||
fixture.controller.freeze { assertFalse(it) }
|
||||
assertEquals(1, fixture.audioResumes)
|
||||
fixture.missingGameStat = false
|
||||
fixture.sync()
|
||||
fixture.controller.resume { assertTrue(it) }
|
||||
assertTrue(fixture.game.threads.all { it.state == 'S' })
|
||||
}
|
||||
|
||||
@Test fun unavailableOrEmptyThreadInventoryCannotReportSuccess() {
|
||||
for (empty in listOf(false, true)) {
|
||||
val fixture = fixture(17)
|
||||
fixture.emptyGameTasks = empty
|
||||
fixture.missingGameTasks = !empty
|
||||
fixture.sync()
|
||||
fixture.controller.freeze { assertFalse(it) }
|
||||
assertEquals(1, fixture.audioResumes)
|
||||
assertTrue(fixture.game.threads.all { it.state == 'S' })
|
||||
}
|
||||
}
|
||||
|
||||
@Test fun disappearingRootFailsAndStillResumesKnownChildren() {
|
||||
val fixture = fixture(17)
|
||||
fixture.afterSleep = {
|
||||
if (fixture.root.threads.first().state == 'T') fixture.rootGone = true
|
||||
}
|
||||
fixture.controller.freeze { assertFalse(it) }
|
||||
assertTrue(fixture.game.threads.all { it.state == 'S' })
|
||||
assertEquals(1, fixture.audioResumes)
|
||||
}
|
||||
|
||||
@Test fun replacementRootIsNeverStoppedOrContinued() {
|
||||
val fixture = fixture(17)
|
||||
var atReplacement = -1
|
||||
fixture.afterSleep = {
|
||||
if (atReplacement < 0 && fixture.root.threads.first().state == 'T') {
|
||||
atReplacement = fixture.signals.size
|
||||
fixture.root.threads.first().apply { started++; state = 'S' }
|
||||
}
|
||||
}
|
||||
fixture.controller.freeze { assertFalse(it) }
|
||||
assertTrue(atReplacement > 0)
|
||||
assertFalse(fixture.signals.drop(atReplacement).any { it.pid == ROOT })
|
||||
assertTrue(fixture.game.threads.all { it.state == 'S' })
|
||||
}
|
||||
|
||||
@Test fun reusedChildPidIsNotContinuedDuringResume() {
|
||||
val fixture = fixture(17)
|
||||
fixture.controller.freeze { assertTrue(it) }
|
||||
fixture.game.threads.first().apply { started++; state = 'S' }
|
||||
fixture.game.parent = 1
|
||||
fixture.game.tracer = 0
|
||||
fixture.sync()
|
||||
val before = fixture.signals.size
|
||||
fixture.controller.resume { assertTrue(it) }
|
||||
assertFalse(fixture.signals.drop(before).any { it.pid == GAME })
|
||||
}
|
||||
|
||||
@Test fun closeCancelsFreezeAndRestoresSavedRootAfterServiceClearsIt() {
|
||||
val executor = QueueExecutor()
|
||||
val fixture = fixture(68, executor)
|
||||
var closed = false
|
||||
var requested = false
|
||||
fixture.afterSleep = {
|
||||
if (!requested && fixture.root.threads.first().state == 'T') {
|
||||
requested = true
|
||||
fixture.rootPid = -1
|
||||
fixture.controller.closeAndResume { closed = true }
|
||||
}
|
||||
}
|
||||
fixture.controller.freeze { assertFalse(it) }
|
||||
executor.drain()
|
||||
assertTrue(closed)
|
||||
assertTrue(executor.isShutdown)
|
||||
assertTrue(fixture.game.threads.all { it.state == 'S' })
|
||||
assertEquals(1, fixture.audioResumes)
|
||||
}
|
||||
|
||||
@Test fun successfulFreezeIsRecheckedAndAudioIsReassertedAfterFailedResume() {
|
||||
val fixture = fixture(17)
|
||||
fixture.controller.freeze { assertTrue(it) }
|
||||
fixture.blockGameContinue = true
|
||||
fixture.controller.resume { assertFalse(it) }
|
||||
assertEquals(1, fixture.audioResumes)
|
||||
fixture.blockGameContinue = false
|
||||
fixture.game.threads.last().state = 'S'
|
||||
fixture.sync()
|
||||
fixture.controller.freeze { assertTrue(it) }
|
||||
assertTrue(fixture.game.threads.all { it.state == 't' })
|
||||
assertEquals(2, fixture.audioSuspends)
|
||||
}
|
||||
|
||||
@Test fun failedRollbackCanBeRefrozenAndAudioIsSuspendedAgain() {
|
||||
val fixture = fixture(17)
|
||||
fixture.neverStop = true
|
||||
fixture.blockGameContinue = true
|
||||
fixture.controller.freeze { assertFalse(it) }
|
||||
fixture.neverStop = false
|
||||
fixture.blockGameContinue = false
|
||||
fixture.controller.freeze { assertTrue(it) }
|
||||
assertTrue(fixture.game.threads.all { it.state == 't' })
|
||||
assertEquals(2, fixture.audioSuspends)
|
||||
assertEquals(1, fixture.audioResumes)
|
||||
}
|
||||
|
||||
@Test fun repeatedFreezeResumeKeepsOriginalRootFirstOrdering() {
|
||||
val fixture = fixture(17)
|
||||
repeat(2) {
|
||||
fixture.controller.freeze { assertTrue(it) }
|
||||
val before = fixture.signals.size
|
||||
fixture.controller.resume { assertTrue(it) }
|
||||
assertEquals(ROOT, fixture.signals.drop(before).first().pid)
|
||||
assertTrue(fixture.game.threads.all { it.state == 'S' })
|
||||
}
|
||||
fixture.controller.freeze { assertTrue(it) }
|
||||
fixture.rootPid = -1
|
||||
var closed = false
|
||||
fixture.controller.closeAndResume { closed = true }
|
||||
assertTrue(closed)
|
||||
assertTrue(fixture.game.threads.all { it.state == 'S' })
|
||||
}
|
||||
|
||||
@Test fun rejectedExecutorDoesNotFreezeOnTheCallingThread() {
|
||||
val executor = QueueExecutor().apply { shutdown() }
|
||||
val fixture = fixture(17, executor)
|
||||
fixture.controller.freeze { assertFalse(it) }
|
||||
assertTrue(fixture.signals.isEmpty())
|
||||
assertEquals(0, fixture.audioSuspends)
|
||||
}
|
||||
|
||||
private fun fixture(count: Int, executor: QueueExecutor = InlineExecutor()) =
|
||||
Fixture(temporary.newFolder(), count, executor)
|
||||
|
||||
private data class Task(val tid: Int, var started: Long, var state: Char, var cpu: Long = 0)
|
||||
private data class Group(val pid: Int, var parent: Int, var tracer: Int, val threads: MutableList<Task>)
|
||||
private data class SentSignal(val pid: Int, val signal: Int)
|
||||
|
||||
private class Fixture(val proc: File, count: Int, executor: QueueExecutor) {
|
||||
val root = Group(ROOT, 9000, 0, mutableListOf(Task(ROOT, 1000, 'S')))
|
||||
val game = Group(GAME, ROOT, ROOT, MutableList(count) { Task(GAME + it, 2000L + it, 'S') })
|
||||
val groups = mutableListOf(root, game)
|
||||
val helpers = mutableListOf<Int>()
|
||||
val signals = mutableListOf<SentSignal>()
|
||||
var rootPid = ROOT
|
||||
var now = 0L
|
||||
var audioSuspends = 0
|
||||
var audioResumes = 0
|
||||
var neverStop = false
|
||||
var blockGameContinue = false
|
||||
var missingGameStat = false
|
||||
var missingGameTasks = false
|
||||
var emptyGameTasks = false
|
||||
var rootGone = false
|
||||
var afterSleep: (() -> Unit)? = null
|
||||
private var continuing = false
|
||||
val controller = SessionSuspendController(
|
||||
{ rootPid }, { helpers }, { audioSuspends++ }, { audioResumes++ },
|
||||
proc, ::signal, ::threadSignal, ::sleep, { now }, executor,
|
||||
)
|
||||
|
||||
init { sync() }
|
||||
|
||||
private fun signal(pid: Int, signal: Int) {
|
||||
signals += SentSignal(pid, signal)
|
||||
val group = groups.first { it.pid == pid }
|
||||
if (signal == STOP) {
|
||||
continuing = false
|
||||
if (pid == ROOT) group.threads.forEach { it.state = 'T' }
|
||||
else group.threads.firstOrNull {
|
||||
it.state !in listOf('T', 't', 'Z', 'X') && !(neverStop && it == game.threads.last())
|
||||
}?.state = 't'
|
||||
} else if (signal == CONT) {
|
||||
continuing = true
|
||||
if (!(pid == GAME && blockGameContinue)) group.threads.forEach { if (it.state != 'Z') it.state = 'S' }
|
||||
}
|
||||
sync()
|
||||
}
|
||||
|
||||
private fun threadSignal(pid: Int, tid: Int, signal: Int) {
|
||||
signals += SentSignal(pid, signal)
|
||||
val task = groups.first { it.pid == pid }.threads.first { it.tid == tid }
|
||||
if (signal == STOP && task.state !in listOf('T', 't', 'Z', 'X') && !(neverStop && task == game.threads.last())) {
|
||||
task.state = 't'
|
||||
}
|
||||
sync()
|
||||
}
|
||||
|
||||
private fun sleep(millis: Long) {
|
||||
now += millis
|
||||
if (root.threads.first().state != 'T' && !continuing) game.threads.forEach {
|
||||
if (it.state != 'Z') { it.state = 'S'; it.cpu++ }
|
||||
}
|
||||
afterSleep?.invoke()
|
||||
sync()
|
||||
}
|
||||
|
||||
fun sync() {
|
||||
for (group in groups) {
|
||||
val dir = File(proc, group.pid.toString())
|
||||
if (group == root && rootGone) { dir.deleteRecursively(); continue }
|
||||
dir.mkdirs()
|
||||
val stat = File(dir, "stat")
|
||||
if (group == game && missingGameStat) stat.delete()
|
||||
else stat.writeText(stat(group, group.threads.first()))
|
||||
File(dir, "status").writeText("TracerPid: ${group.tracer}\n")
|
||||
val taskDir = File(dir, "task")
|
||||
if (group == game && missingGameTasks) { taskDir.deleteRecursively(); continue }
|
||||
taskDir.mkdirs()
|
||||
if (group == game && emptyGameTasks) { taskDir.listFiles().orEmpty().forEach { it.deleteRecursively() }; continue }
|
||||
for (task in group.threads) {
|
||||
val entry = File(taskDir, task.tid.toString()).apply { mkdirs() }
|
||||
File(entry, "stat").writeText(stat(group, task))
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private fun stat(group: Group, task: Task): String {
|
||||
val fields = MutableList(20) { "0" }
|
||||
fields[0] = task.state.toString()
|
||||
fields[1] = group.parent.toString()
|
||||
fields[11] = task.cpu.toString()
|
||||
fields[19] = task.started.toString()
|
||||
return "${task.tid} (fixture (worker)) ${fields.joinToString(" ")}"
|
||||
}
|
||||
}
|
||||
|
||||
private open class QueueExecutor : AbstractExecutorService() {
|
||||
private val queue = ArrayDeque<Runnable>()
|
||||
private var stopped = false
|
||||
override fun execute(command: Runnable) {
|
||||
if (stopped) throw RejectedExecutionException()
|
||||
queue.add(command)
|
||||
}
|
||||
fun drain() { while (queue.isNotEmpty()) queue.removeFirst().run() }
|
||||
override fun shutdown() { stopped = true }
|
||||
override fun shutdownNow(): MutableList<Runnable> {
|
||||
stopped = true
|
||||
return queue.toMutableList().also { queue.clear() }
|
||||
}
|
||||
override fun isShutdown() = stopped
|
||||
override fun isTerminated() = stopped && queue.isEmpty()
|
||||
override fun awaitTermination(timeout: Long, unit: TimeUnit) = isTerminated
|
||||
}
|
||||
|
||||
private class InlineExecutor : QueueExecutor() {
|
||||
override fun execute(command: Runnable) { super.execute(command); drain() }
|
||||
}
|
||||
|
||||
private companion object {
|
||||
const val ROOT = 100
|
||||
const val GAME = 200
|
||||
const val STOP = 19
|
||||
const val CONT = 18
|
||||
}
|
||||
}
|
||||
@@ -126,6 +126,7 @@ struct userdata {
|
||||
unsigned int decay_backoff, cb_count, wd_last_cb;
|
||||
int reopen_running, reopen_redo;
|
||||
int consuming, primed, starved;
|
||||
int suspended;
|
||||
volatile int dead;
|
||||
|
||||
/* what the IO thread last logged, so engine changes made on the AAudio thread get a line */
|
||||
@@ -302,6 +303,7 @@ static void out_error_cb(AAudioStream *aq, void *user, aaudio_result_t error) {
|
||||
struct userdata *u = user;
|
||||
|
||||
if (aq != __atomic_load_n(&u->aq, __ATOMIC_SEQ_CST)) return;
|
||||
if (__atomic_load_n(&u->suspended, __ATOMIC_SEQ_CST)) return;
|
||||
/* A disconnected stream (headphones plugged or unplugged, a Bluetooth route coming or going)
|
||||
* can never be restarted: it has to be closed and a new one opened on the current route. */
|
||||
if (error != AAUDIO_ERROR_DISCONNECTED &&
|
||||
@@ -400,6 +402,8 @@ static void *reopen_thread(void *user) {
|
||||
pthread_mutex_lock(&u->lock);
|
||||
old = u->aq;
|
||||
__atomic_store_n(&u->aq, neu, __ATOMIC_SEQ_CST);
|
||||
if (__atomic_load_n(&u->suspended, __ATOMIC_SEQ_CST))
|
||||
AAudioStream_requestStop(neu);
|
||||
pthread_mutex_unlock(&u->lock);
|
||||
} else
|
||||
pa_log("directaudio-native-sink: reopen failed; keeping the old stream");
|
||||
@@ -575,6 +579,34 @@ static int sink_process_msg(pa_msgobject *o, int code, void *data, int64_t offse
|
||||
return pa_sink_process_msg(o, code, data, offset, chunk);
|
||||
}
|
||||
|
||||
/* A started AAudio stream keeps audioserver's AudioMix wake lock held, so the device never
|
||||
* suspends while the session sleeps: stop it, and the IO thread's timer, until the sink reopens. */
|
||||
static int sink_set_state_in_io_thread_cb(pa_sink *s, pa_sink_state_t new_state, pa_suspend_cause_t new_suspend_cause) {
|
||||
struct userdata *u = s->userdata;
|
||||
aaudio_result_t res = AAUDIO_OK;
|
||||
|
||||
if (new_state == PA_SINK_SUSPENDED && !u->suspended) {
|
||||
pthread_mutex_lock(&u->lock);
|
||||
__atomic_store_n(&u->suspended, 1, __ATOMIC_SEQ_CST);
|
||||
if (u->aq) AAudioStream_requestStop(u->aq);
|
||||
pthread_mutex_unlock(&u->lock);
|
||||
pa_rtpoll_set_timer_disabled(u->rtpoll);
|
||||
pa_log("directaudio-native-sink: suspended; output stopped");
|
||||
} else if (PA_SINK_IS_OPENED(new_state) && u->suspended) {
|
||||
pthread_mutex_lock(&u->lock);
|
||||
__atomic_store_n(&u->suspended, 0, __ATOMIC_SEQ_CST);
|
||||
u->primed = 0;
|
||||
__atomic_store_n(&u->last_cb_ns, now_ns(), __ATOMIC_SEQ_CST);
|
||||
u->wd_last_tick_ns = 0;
|
||||
if (u->aq) res = AAudioStream_requestStart(u->aq);
|
||||
pthread_mutex_unlock(&u->lock);
|
||||
if (res != AAUDIO_OK || !u->aq) request_reopen(u, "resume");
|
||||
pa_rtpoll_set_timer_relative(u->rtpoll, 0);
|
||||
pa_log("directaudio-native-sink: resumed");
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void thread_func(void *userdata) {
|
||||
struct userdata *u = userdata;
|
||||
|
||||
@@ -592,8 +624,10 @@ static void thread_func(void *userdata) {
|
||||
/* Half a burst between visits, never blocking on the stream: clients' audio reaches this
|
||||
* thread as messages pa_rtpoll_run handles, and a thread stuck in a write or a wait lets
|
||||
* them run dry (the crackle #338 fixed). */
|
||||
service_ring(u);
|
||||
pa_rtpoll_set_timer_relative(u->rtpoll, PA_MAX(frames_to_usec(u, u->burst) / 2, PA_USEC_PER_MSEC));
|
||||
if (!u->suspended) {
|
||||
service_ring(u);
|
||||
pa_rtpoll_set_timer_relative(u->rtpoll, PA_MAX(frames_to_usec(u, u->burst) / 2, PA_USEC_PER_MSEC));
|
||||
}
|
||||
|
||||
if ((ret = pa_rtpoll_run(u->rtpoll)) < 0)
|
||||
goto fail;
|
||||
@@ -727,6 +761,7 @@ int pa__init(pa_module *m) {
|
||||
goto fail;
|
||||
}
|
||||
u->sink->parent.process_msg = sink_process_msg;
|
||||
u->sink->set_state_in_io_thread = sink_set_state_in_io_thread_cb;
|
||||
u->sink->userdata = u;
|
||||
pa_sink_set_asyncmsgq(u->sink, u->thread_mq.inq);
|
||||
pa_sink_set_rtpoll(u->sink, u->rtpoll);
|
||||
|
||||
Reference in new issue
Block a user