From 2c8326f01656d2f25a9314be4405628b6235732f Mon Sep 17 00:00:00 2001 From: Davide Depau Date: Tue, 30 Jun 2026 22:17:06 +0200 Subject: [PATCH] fix: ensure closeAsync joins I/O thread to prevent libusb crash --- .../massstorage/BlockDeviceInputStream.kt | 24 +++++- .../massstorage/BlockDeviceOutputStream.kt | 24 +++++- .../depau/etchdroid/BlockDeviceStreamTest.kt | 82 +++++++++++++++++++ 3 files changed, 128 insertions(+), 2 deletions(-) diff --git a/app/src/main/java/eu/depau/etchdroid/massstorage/BlockDeviceInputStream.kt b/app/src/main/java/eu/depau/etchdroid/massstorage/BlockDeviceInputStream.kt index 5c3adc8..f33c79e 100644 --- a/app/src/main/java/eu/depau/etchdroid/massstorage/BlockDeviceInputStream.kt +++ b/app/src/main/java/eu/depau/etchdroid/massstorage/BlockDeviceInputStream.kt @@ -4,10 +4,12 @@ import android.util.Log import eu.depau.etchdroid.utils.AsyncInputStream import kotlinx.coroutines.CoroutineScope import kotlinx.coroutines.Dispatchers +import kotlinx.coroutines.Job import kotlinx.coroutines.channels.Channel import kotlinx.coroutines.channels.ClosedReceiveChannelException import kotlinx.coroutines.channels.ClosedSendChannelException import kotlinx.coroutines.launch +import kotlinx.coroutines.withTimeoutOrNull import me.jahnen.libaums.core.driver.BlockDeviceDriver import java.io.IOException import java.nio.ByteBuffer @@ -18,6 +20,14 @@ private const val TAG = "BlockDeviceInputStream" private const val TRACE_IO = false +/** + * Upper bound on how long [BlockDeviceInputStream.closeAsync] waits for the I/O worker to + * terminate. On a healthy device the worker exits in milliseconds once the channel is closed; the + * timeout only trips if a native libusb transfer is genuinely stuck, in which case the job is + * failing anyway and we must not block close() forever. + */ +private const val IO_THREAD_JOIN_TIMEOUT_MS = 10_000L + /** * Helper function to trace I/O operations. * @@ -110,6 +120,12 @@ class BlockDeviceInputStream( */ private val mIoThreadRunning: AtomicBoolean = AtomicBoolean(false) + /** + * The coroutine running the I/O thread, so [closeAsync] can wait for it to fully terminate + * (i.e. no native block-device transfer is still in flight) before returning. + */ + private var mIoThreadJob: Job? = null + /** * Waits until the wanted block is available in the block channel and returns it. Note that the * returned data may not necessarily *start* at the wanted block, but it will contain it. @@ -165,7 +181,7 @@ class BlockDeviceInputStream( val rendezvous = Channel() - coroutineScope.launch(Dispatchers.IO) { + mIoThreadJob = coroutineScope.launch(Dispatchers.IO) { Thread.currentThread().name = "BlockDeviceInputStream I/O thread" try { @@ -442,6 +458,12 @@ class BlockDeviceInputStream( } catch (e: ClosedReceiveChannelException) { // Ignore } + + // Wait for the I/O worker to fully terminate so no native block-device read is still in + // flight when the caller moves on: the underlying libusb handle is not safe against + // concurrent transfers and would crash natively. + withTimeoutOrNull(IO_THREAD_JOIN_TIMEOUT_MS) { mIoThreadJob?.join() } + ?: Log.w(TAG, "I/O worker did not terminate before close") } /** diff --git a/app/src/main/java/eu/depau/etchdroid/massstorage/BlockDeviceOutputStream.kt b/app/src/main/java/eu/depau/etchdroid/massstorage/BlockDeviceOutputStream.kt index 5484759..9669775 100644 --- a/app/src/main/java/eu/depau/etchdroid/massstorage/BlockDeviceOutputStream.kt +++ b/app/src/main/java/eu/depau/etchdroid/massstorage/BlockDeviceOutputStream.kt @@ -6,12 +6,14 @@ import kotlinx.coroutines.CoroutineScope import kotlinx.coroutines.DelicateCoroutinesApi import kotlinx.coroutines.Dispatchers import kotlinx.coroutines.ExperimentalCoroutinesApi +import kotlinx.coroutines.Job import kotlinx.coroutines.channels.Channel import kotlinx.coroutines.channels.ClosedReceiveChannelException import kotlinx.coroutines.launch import kotlinx.coroutines.sync.Mutex import kotlinx.coroutines.sync.withLock import kotlinx.coroutines.withContext +import kotlinx.coroutines.withTimeoutOrNull import me.jahnen.libaums.core.driver.BlockDeviceDriver import java.io.IOException import java.nio.ByteBuffer @@ -21,6 +23,14 @@ private const val TAG = "BlockDeviceOutputStream" private const val BARRIER_TAG = -0xBA881E8L +/** + * Upper bound on how long [BlockDeviceOutputStream.closeAsync] waits for the I/O worker to + * terminate. On a healthy device the worker exits in milliseconds once the channel is closed; the + * timeout only trips if a native libusb transfer is genuinely stuck, in which case the job is + * failing anyway and we must not block close() forever. + */ +private const val IO_THREAD_JOIN_TIMEOUT_MS = 10_000L + private const val TRACE_IO = false /** @@ -116,6 +126,12 @@ class BlockDeviceOutputStream( */ private val mIoThreadRunning: AtomicBoolean = AtomicBoolean(false) + /** + * The coroutine running the I/O thread, so [closeAsync] can wait for it to fully terminate + * (i.e. no native block-device transfer is still in flight) before returning. + */ + private var mIoThreadJob: Job? = null + /** * Atomic flag that indicates whether the stream has been closed. */ @@ -144,7 +160,7 @@ class BlockDeviceOutputStream( } } - coroutineScope.launch(Dispatchers.IO) { + mIoThreadJob = coroutineScope.launch(Dispatchers.IO) { Thread.currentThread().name = "BlockDeviceOutputStream I/O thread" if (!mIoThreadRunning.compareAndSet(false, true)) { @@ -383,5 +399,11 @@ class BlockDeviceOutputStream( flushAsync() val channel = mChannelMutex.withLock { mBlockChannel } channel.close() + + // Wait for the I/O worker to fully terminate so no native block-device transfer is still + // in flight when the caller moves on (e.g. the write->verify handoff): the underlying + // libusb handle is not safe against concurrent transfers and would crash natively. + withTimeoutOrNull(IO_THREAD_JOIN_TIMEOUT_MS) { mIoThreadJob?.join() } + ?: Log.w(TAG, "I/O worker did not terminate before close") } } diff --git a/app/src/test/java/eu/depau/etchdroid/BlockDeviceStreamTest.kt b/app/src/test/java/eu/depau/etchdroid/BlockDeviceStreamTest.kt index d70c2ba..f4f6dee 100644 --- a/app/src/test/java/eu/depau/etchdroid/BlockDeviceStreamTest.kt +++ b/app/src/test/java/eu/depau/etchdroid/BlockDeviceStreamTest.kt @@ -1,4 +1,5 @@ @file:OptIn(ExperimentalCoroutinesApi::class) +@file:Suppress("RunBlockingInSuspendFunction") package eu.depau.etchdroid @@ -8,10 +9,15 @@ import kotlinx.coroutines.CoroutineScope import kotlinx.coroutines.Dispatchers import kotlinx.coroutines.ExperimentalCoroutinesApi import kotlinx.coroutines.debug.DebugProbes +import kotlinx.coroutines.delay +import kotlinx.coroutines.launch import kotlinx.coroutines.runBlocking +import me.jahnen.libaums.core.driver.BlockDeviceDriver import org.junit.jupiter.api.AfterAll import org.junit.jupiter.api.Assertions.assertArrayEquals import org.junit.jupiter.api.Assertions.assertEquals +import org.junit.jupiter.api.Assertions.assertFalse +import org.junit.jupiter.api.Assertions.assertTrue import org.junit.jupiter.api.Assertions.fail import org.junit.jupiter.api.BeforeAll import org.junit.jupiter.api.Test @@ -22,6 +28,45 @@ import tech.apter.junit.jupiter.robolectric.RobolectricExtension import java.io.IOException import java.lang.Math.min import java.nio.ByteBuffer +import java.util.concurrent.CountDownLatch +import java.util.concurrent.atomic.AtomicInteger +import kotlin.time.Duration.Companion.milliseconds + +/** + * A block device that parks inside its first [read] until [releaseRead] is counted down, signaling + * via [readStarted] once it has entered the call. Used to prove that closing a stream waits for an + * in-flight native transfer to finish (the libusb concurrency crash, ETCHDROID write->verify). + */ +private class ParkingBlockDeviceDriver( + sizeBytes: Long, + override val blockSize: Int, +) : BlockDeviceDriver { + private val backing = ByteArray(sizeBytes.toInt()) + override val blocks: Long get() = (backing.size / blockSize).toLong() + + val activeReads = AtomicInteger(0) + val readStarted = CountDownLatch(1) + val releaseRead = CountDownLatch(1) + + override fun init() {} + + override fun read(deviceOffset: Long, buffer: ByteBuffer) { + activeReads.incrementAndGet() + try { + readStarted.countDown() + releaseRead.await() + val start = (deviceOffset * blockSize).toInt() + buffer.put(backing, start, buffer.remaining()) + } finally { + activeReads.decrementAndGet() + } + } + + override fun write(deviceOffset: Long, buffer: ByteBuffer) { + val start = (deviceOffset * blockSize).toInt() + buffer.get(backing, start, buffer.remaining()) + } +} @ExperimentalCoroutinesApi @ExtendWith(RobolectricExtension::class) @@ -54,6 +99,43 @@ class BlockDeviceInputStreamTest { assertDoesNotThrow { runBlocking { inputStream.closeAsync() } } } + @Test + fun closeWaitsForInFlightRead() = runBlocking { + // Regression: closeAsync() used to return while the I/O worker was still inside a native + // blockDev.read(). At the write->verify handoff that let two coroutines submit transfers on + // the same libusb handle concurrently, crashing the app natively in libusb_submit_transfer. + val testDev = ParkingBlockDeviceDriver(1L * 1024 * 1024, 512) + val inputStream = + BlockDeviceInputStream(testDev, coroutineScope, bufferBlocks = 1, prefetchBuffers = 1) + + // Trigger the worker; it enters read() and parks. readAsync won't return until the worker + // delivers a block, so run it detached (and swallow the close-induced cancellation). + val readJob = coroutineScope.launch { + try { + inputStream.readAsync(ByteArray(4)) + } catch (_: Exception) { + // Expected: the channel is closed under us by closeAsync(). + } + } + + assertTrue(testDev.readStarted.await(5, java.util.concurrent.TimeUnit.SECONDS)) { + "Worker never entered read()" + } + + val closeJob = coroutineScope.launch { inputStream.closeAsync() } + + // Give closeAsync ample time to run; it must NOT complete while a read is in flight. + delay(500.milliseconds) + assertFalse(closeJob.isCompleted) { "closeAsync returned while a read was still in flight" } + assertTrue(testDev.activeReads.get() > 0) { "Expected a read to be in flight" } + + // Let the read finish; close must now complete and no transfer may remain in flight. + testDev.releaseRead.countDown() + closeJob.join() + readJob.join() + assertEquals(0, testDev.activeReads.get()) + } + @Test fun testWithWeirdBlockSize() { runReadTest(