RESET rebases the PCM application position without updating the indirect capture accounting. The next ACK can interpret that change as a backward application move and return -EPIPE. In a QEMU reproduction, the PCM application position changed from 24000 to 2880 frames while the private position stayed at 24000. Both running and paused capture failed with free-running and buffer-sized stop thresholds.
Use a separate reset operation for indirect capture. The PCM stream lock covers the common pointer reset, private accounting and core completion. Discard the observed unread data and return its buffer space to RX. Keep the hardware and software ring offsets so in-flight completions continue at their existing DMA positions. Set the private application position to the position core will publish on completion. A paused device retains its fixed DMA positions. Keep the observed software ring position as the reset position in this state, instead of making userspace read from offset zero while the device continues at a different offset. Completions after the observation are retained. If returning RX space fails, stop further transfers and return the error. The caller must drop and prepare or reopen the stream after this partial failure. The existing staged reset operation and playback are unchanged. This patch depends on the proposed PCM reset operation and helper in patch 1. The series diff applies after patch 2 because both touch the operation tables. The indirect reset implementation also applies on top of patch 1 alone; an alternate local diff is supplied for that order. The reproduction uses the pending virtio-snd stack with local follow-up corrections described in the cover letter. The earlier RW capture tests covered running and paused RESET, both stop thresholds, a 240 ms read backlog, refill-error recovery and reopen. The core-only plus indirect variant also passed the four RW reset cases. Additional direct MMAP_INTERLEAVED tests used 48 kHz mono S16_LE in ARM64 QEMU. The pre-fix running and paused cases failed after RESET with ACK -EPIPE. All 13 fixed runs passed, including two 1-vCPU 70-second captures, refill -ENOSPC injection, managed overrun recovery and reopen. All 9,072,000 captured frames matched the deterministic source at their expected positions. RESET discards observed unread data; verification starts at the resulting position. Recovery and reopen checks start at the device's new START position. KASAN and lockdep reported no errors. These MMAP runs used the combined local stack with staging disabled. Physical VZ/MOTU, other MMAP layouts, multi-channel input and concurrent RESET between mmap_begin and mmap_commit remain untested for this candidate. Assisted-by: LLM Signed-off-by: Joonho Lee <[email protected]> --- diff --git a/sound/virtio/virtio_pcm_ops.c b/sound/virtio/virtio_pcm_ops.c --- a/sound/virtio/virtio_pcm_ops.c +++ b/sound/virtio/virtio_pcm_ops.c @@ -10,6 +10,7 @@ #include "virtio_card.h" static const struct snd_pcm_ops virtsnd_pcm_capture_staged_ops; +static const struct snd_pcm_ops virtsnd_pcm_capture_indirect_ops; bool virtsnd_capture_staging; module_param_named(capture_staging, virtsnd_capture_staging, bool, 0444); @@ -389,10 +390,13 @@ } } - /* Keep the legacy RESET completion policy outside staged capture. */ + /* Keep RESET operation selection fixed for the opened runtime. */ substream->ops = vss->capture_staging ? &virtsnd_pcm_capture_staged_ops : &virtsnd_pcm_ops[substream->stream]; + + if (vss->direction == SNDRV_PCM_STREAM_CAPTURE && !vss->capture_staging) + substream->ops = &virtsnd_pcm_capture_indirect_ops; snd_pcm_hw_constraint_integer(substream->runtime, SNDRV_PCM_HW_PARAM_PERIODS); @@ -1596,6 +1600,54 @@ return 0; } return virtsnd_pcm_sync_stop_locked(substream); +} + +/* The PCM lock covers both indirect accounting and core completion. */ +static int virtsnd_pcm_indirect_reset(struct snd_pcm_substream *substream) +{ + struct virtio_pcm_substream *vss = snd_pcm_substream_chip(substream); + struct snd_pcm_runtime *runtime = substream->runtime; + struct virtio_snd_queue *queue = virtsnd_pcm_queue(vss); + struct virtsnd_pcm_transfer transfer = {}; + int rc; + + rc = snd_pcm_lib_reset(substream); + if (rc) + return rc; + if (!snd_pcm_running(substream) && + runtime->state != SNDRV_PCM_STATE_PAUSED) + return 0; + + guard(spinlock_irqsave)(&queue->lock); + guard(spinlock)(&vss->lock); + if (vss->resetting) + return -ECANCELED; + if (!vss->prepared || vss->stopped) + return -EBADFD; + + /* Pausing does not move the device's fixed DMA buffer positions. */ + if (runtime->state == SNDRV_PCM_STATE_PAUSED) + runtime->status->hw_ptr = + bytes_to_frames(runtime, vss->pcm_indirect.sw_io); + + transfer.indirect = vss->pcm_indirect; + transfer.indirect.sw_ready = 0; + /* Consume no application delta while returning discarded RX space. */ + transfer.indirect.appl_ptr = runtime->control->appl_ptr; + rc = snd_pcm_indirect_capture_transfer(substream, &transfer.indirect, + virtsnd_pcm_trans_copy); + if (!rc) + rc = transfer.error; + if (rc) { + virtsnd_pcm_transfer_failed(vss); + return rc; + } + + /* RESET discards all samples through the observed software pointer. */ + transfer.indirect.sw_ready = 0; + transfer.indirect.appl_ptr = runtime->status->hw_ptr; + vss->pcm_indirect = transfer.indirect; + return 0; } /* The core holds the stream lock through the matching appl_ptr reset. */ @@ -1691,3 +1743,17 @@ .pointer = virtsnd_pcm_cp_pointer, .ack = virtsnd_pcm_cp_ack, }; + +static const struct snd_pcm_ops virtsnd_pcm_capture_indirect_ops = { + .open = virtsnd_pcm_open, + .close = virtsnd_pcm_close, + .ioctl = snd_pcm_lib_ioctl, + .reset = virtsnd_pcm_indirect_reset, + .hw_params = virtsnd_pcm_hw_params, + .hw_free = virtsnd_pcm_hw_free, + .prepare = virtsnd_pcm_prepare, + .trigger = virtsnd_pcm_trigger, + .sync_stop = virtsnd_pcm_sync_stop, + .pointer = virtsnd_pcm_cp_pointer, + .ack = virtsnd_pcm_cp_ack, +};
