ALSA: virtio: preserve PCM progress
Subsystems (4)
v30 cover ALSA: virtio: preserve PCM progress
This v30 revision resends v29 with no code changes. Patch 17 clarifies the commit description and moves qualification limits to this cover letter, following the review. The other patch messages and code are unchanged.
Previous version:
https://lore.kernel.org/linux-sound/[email protected]/T/
This resends v28 in full using [email protected] for every message. There are no code or patch-description changes from v28; the existing human DCO trailers are retained.
The v28 documentation patch 14 was rejected by Gmail. Sending that message through my Workspace account made it available on Lore, but Sashiko grouped it separately from the other sixteen patches. This revision sends the complete series with one From address.
Previous version:
https://lore.kernel.org/linux-sound/[email protected]/T/
The following describes the changes and validation already included in v28.
This replaces v27 in full. Apply all seventeen patches directly to base commit a4311e9447bbb219044db38897f95be112f46a8a. The previous public version is at:
https://lore.kernel.org/linux-sound/[email protected]/T/
Changes since v27 are confined to patch 12. The other patch diffs are unchanged.
I reproduced both capture findings from the Sashiko review. If request N+1 completed before N, RESET could leave N+1's already completed payload eligible for later delivery. After an external XRUN, rejecting N also left N+1 buffered until generation cleanup. PREPARE cleared that state in the control test, so this does not establish a permanent recovery failure.
RESET now marks valid completed payloads present at the pointer observation as discarded while retaining their ordered placeholders. This lets the commit sequence advance when older requests return. Transport-owned requests and data arriving after the observation remain eligible to commit. Repeated RESET preserves the discard, and invalid response status still reports XRUN. Rejected completions also release returned buffered entries without resetting the sequence of requests still owned by the transport.
The failed native PAUSE path previously reopened the queue with the STOP quiet boundary and capture_stopping flag still set. A running stream could then accept an empty completion without the normal XRUN check. Rollback now restores the prior flags under the substream lock and checks the reset epoch before reopening admission.
ARM64 QEMU tests use the actual driver functions with test-only request ordering and STOP allocation-failure injection. The v27 baseline fails eight affected assertions; the candidate passes all thirteen assertions, including normal reordering, post-observation delivery, invalid status, and STOP empty-tail controls. The running-observation test invokes the actual pointer-observation helper. Full RUNNING RESET ioctls are covered separately by the production regression.
The production driver module was built separately without those hooks. Its ARM64 W=1 build and eight QEMU regression runs passed with the matching v27 KASAN/lockdep kernel and core modules. These cover RW/MMAP capture, PREPARED RESET with DRAIN/reopen, RUNNING RESET, and playback PAUSE/RELEASE, HWSYNC/poll, DROP and reopen. Capture includes 70-second RW and resumed MMAP phases. The independent backend-sequence oracle matched 7,104,000 frames across seven capture phases. No KASAN or lockdep diagnostic appeared.
The kernel image and core were reused unchanged; the modified driver was rebuilt. Fresh KCSAN and physical VZ tests were not run for this revision. The earlier v27 KCSAN and Scarlett results describe that earlier build. The controlled tests use synthetic requests and a known STOP failure before submission; they do not qualify transport timeout/uncertainty or demonstrate out-of-order completions on physical hardware. Intermediate patch stages are application-checked; the fresh runtime tests cover the final candidate.
Review addressed:
https://lore.kernel.org/linux-sound/[email protected]/
Playback validation limits: The one-period reduction in the TX queue has not been qualified for worst-case scheduling tolerance. The tree through the preceding playback-completion change was inspected but not run separately. The playback gate tests used ARM64 QEMU; they did not include KCSAN or physical audio. They do not qualify the full series.
base-commit: a4311e9447bbb219044db38897f95be112f46a8a
PATCH v30 1/17 ALSA: pcm: mark stop-threshold accesses for capture policy sampling
The staged virtio-snd capture path needs to sample stop_threshold from completion context to distinguish free-running capture from bounded capture. Software parameters can update this field while capture runs.
Mark the runtime stop-threshold assignments with WRITE_ONCE and the proc status read with READ_ONCE. This pairs the assignments with the driver's staged-capture policy sampling.
These annotations do not provide a transaction for the entire sw_params update. The driver serializes its cached policy and accounting with its own substream lock.
---sound/core/oss/pcm_oss.c | 2 +-
sound/core/pcm.c | 3 ++- sound/core/pcm_native.c | 5 +++-- 3 files changed, 6 insertions(+), 4 deletions(-)
sound/core/oss/pcm_oss.c +1 -1
@@ -2958,7 +2958,7 @@ runtime->oss.mmap_bytes);#endif /* In mmap mode we never stop */ - runtime->stop_threshold = runtime->boundary; +WRITE_ONCE (runtime->stop_threshold, runtime->boundary);return 0 ; }
sound/core/pcm.c +2 -1
@@ -422,7 +422,8 @@snd_iprintf (buffer,"period_step: %u\n" , runtime->period_step);snd_iprintf (buffer,"avail_min: %lu\n" , runtime->control->avail_min);snd_iprintf (buffer,"start_threshold: %lu\n" , runtime->start_threshold); -snd_iprintf (buffer,"stop_threshold: %lu\n" , runtime->stop_threshold); +snd_iprintf (buffer,"stop_threshold: %lu\n" , +READ_ONCE (runtime->stop_threshold));snd_iprintf (buffer,"silence_threshold: %lu\n" , runtime->silence_threshold);snd_iprintf (buffer,"silence_size: %lu\n" , runtime->silence_size);snd_iprintf (buffer,"boundary: %lu\n" , runtime->boundary);
sound/core/pcm_native.c +3 -2
@@ -871,7 +871,7 @@ runtime->period_step =1 ; runtime->control->avail_min = runtime->period_size; runtime->start_threshold =1 ; - runtime->stop_threshold = runtime->buffer_size; +WRITE_ONCE (runtime->stop_threshold, runtime->buffer_size); runtime->silence_threshold =0 ; runtime->silence_size =0 ; runtime->boundary = runtime->buffer_size;
@@ -1062,7 +1062,8 @@ runtime->period_step = params->period_step; runtime->control->avail_min = params->avail_min; runtime->start_threshold = params->start_threshold; - runtime->stop_threshold = params->stop_threshold; +/* Drivers may sample the stop policy from completion context. */ +WRITE_ONCE (runtime->stop_threshold, params->stop_threshold); runtime->silence_threshold = params->silence_threshold; runtime->silence_size = params->silence_size; params->boundary = runtime->boundary;
PATCH v30 2/17 ALSA: pcm: report partial progress under the stream lock
In reply to Joonho LeeAllow a driver to publish subperiod progress under the PCM stream lock without generating a period timer notification. Use the ordinary pointer update, XRUN and wakeup path. Capture DRAINING can publish its final tail while playback and other inactive states retain their existing behavior.
Handle capture DRAINING separately in the state update: a full buffer is still readable capture data, while progress beyond the buffer capacity is an overrun. Playback continues to finish draining when its buffer is empty.
Refresh capture availability after the unlocked copy and application pointer commit while DRAINING. A final tail can arrive during the copy; subtracting only the copied frames from the earlier snapshot can otherwise finish draining with unread samples left in the ring.
---include/sound/pcm.h | 1 +
sound/core/pcm_lib.c | 40 +++++++++++++++++++++++++++++++++++++--- 2 files changed, 38 insertions(+), 3 deletions(-)
include/sound/pcm.h +1 -0
@@ -1182,6 +1182,7 @@int snd_pcm_lib_ioctl (struct snd_pcm_substream *substream,unsigned int cmd,void *arg);void snd_pcm_period_elapsed_under_stream_lock (struct snd_pcm_substream *substream); +void snd_pcm_progress_under_stream_lock (struct snd_pcm_substream *substream);void snd_pcm_period_elapsed (struct snd_pcm_substream *substream); snd_pcm_sframes_t __snd_pcm_lib_xfer(struct snd_pcm_substream *substream, void *buf, bool interleaved,
sound/core/pcm_lib.c +37 -3
@@ -215,8 +215,14 @@if (avail > runtime->avail_max) runtime->avail_max = avail;if (runtime->state ==SNDRV_PCM_STATE_DRAINING ) { -if (avail >= runtime->buffer_size) { -snd_pcm_drain_done (substream); +if (substream->stream ==SNDRV_PCM_STREAM_PLAYBACK ) { +if (avail >= runtime->buffer_size) { +snd_pcm_drain_done (substream); +return -EPIPE ; + } + }else if (avail > runtime->buffer_size) { +/* A full capture buffer remains readable while draining. */ +__snd_pcm_xrun (substream);return -EPIPE ; } }else {
@@ -1919,6 +1925,30 @@EXPORT_SYMBOL (snd_pcm_period_elapsed_under_stream_lock);/** +* snd_pcm_progress_under_stream_lock - Report progress without a period IRQ +* @substream: PCM substream +* +* Context: PCM stream lock held, with no driver pointer or trigger locks held. +* Updates the pointer and wakes readers for partial-period transfers. Capture +* streams may report their final tail while DRAINING. Unlike a period +* notification, this does not imply an elapsed period or tick the PCM timer. +* The same pointer, trigger and timestamp callbacks may be invoked. +*/ +void snd_pcm_progress_under_stream_lock (struct snd_pcm_substream *substream) +{ +if (PCM_RUNTIME_CHECK (substream)) +return ; +if (!snd_pcm_running (substream) && + !(substream->stream ==SNDRV_PCM_STREAM_CAPTURE && + substream->runtime->state ==SNDRV_PCM_STATE_DRAINING )) +return ; +snd_pcm_update_hw_ptr (substream); +snd_kill_fasync (substream->runtime->fasync,SIGIO ,POLL_IN ); +} +EXPORT_SYMBOL_GPL (snd_pcm_progress_under_stream_lock); + + +/** * snd_pcm_period_elapsed() - update the status of runtime for the next period by acquiring lock of * PCM substream. * @substream: the instance of PCM substream.
@@ -2405,7 +2435,11 @@ offset += frames; size -= frames; xfer += frames; - avail -= frames; +if (!is_playback && + runtime->state ==SNDRV_PCM_STATE_DRAINING ) + avail =snd_pcm_avail (substream); +else + avail -= frames;if (is_playback && runtime->state ==SNDRV_PCM_STATE_PREPARED &&snd_pcm_playback_hw_avail (runtime) >= (snd_pcm_sframes_t )runtime->start_threshold) {
PATCH v30 3/17 ALSA: pcm: add an optional reset operation under the stream lock
In reply to Joonho LeeA driver may need to synchronize private capture accounting with the common RESET pointer observation and the core's position rebase.
Add an optional reset operation called under the member's stream lock. Expose snd_pcm_lib_reset() so the callback can retain common pointer and time handling. On zero return the core completes that member's rebase before unlocking it. Drivers without the callback retain the ioctl path. The operation is also used after a successful prepare.
Zero permits the position rebase; it does not promise XRUN recovery. A negative return skips the core rebase, so a callback returning an error must leave coherent pointer state even after partial work.
Linked RESET and prepare stop at the first error without rollback. Earlier callback members may already have completed. Legacy members keep the existing post_action policy. Applications must recover the group after partial failure before relying on shared positions.
This adds an internal kernel operation and no userspace ioctl or layout. Out-of-tree modules using snd_pcm_ops need to be rebuilt.
Complete appl_ptr rebasing once in the callback path. A later linked member can sleep in prepare while the earlier member accepts SYNC_PTR; a subsequent unlocked post_prepare assignment would overwrite that acknowledgment. Keep explicit RESET playback silence processing and leave prepare-time filling to the normal START path, preserving samples written and rewound after prepare.
---include/sound/pcm.h | 21 +++++++++++++++++++++
sound/core/pcm_lib.c | 29 ++++++++++++++++++++++++----- sound/core/pcm_native.c | 45 ++++++++++++++++++++++++++++++++++++++++----- 3 files changed, 85 insertions(+), 10 deletions(-)
include/sound/pcm.h +21 -0
@@ -77,6 +77,26 @@ unsigned long offset);int (*mmap)(struct snd_pcm_substream *substream,struct vm_area_struct *vma);int (*ack)(struct snd_pcm_substream *substream); +/* +* Optional RESET operation, also used after a successful prepare. +* Called with this substream's PCM lock held; atomic streams must not +* sleep. Do not reacquire the PCM lock through snd_pcm_lib_ioctl(). +* snd_pcm_lib_reset() provides the common pointer update under this +* lock. The core completes the position and appl_ptr rebase before +* unlocking a successful member. +* +* Return zero to let the core complete the position rebase. As with +* the legacy RESET ioctl, zero does not guarantee recovery from XRUN; +* callers must still handle the stream state and subsequent I/O errors. +* On a negative return the core does not finish the rebase, so the +* callback must leave coherent pointer state even after partial work. +* +* Linked RESET/prepare +* stops at the first error without rollback. Earlier callback members +* retain their completed reset; legacy members retain the existing +* post_action policy. An error does not guarantee unchanged state. +*/ +int (*reset)(struct snd_pcm_substream *substream); };/*
@@ -1179,6 +1199,7 @@ { substream->runtime->std_sync_id = true; } +int snd_pcm_lib_reset (struct snd_pcm_substream *substream);int snd_pcm_lib_ioctl (struct snd_pcm_substream *substream,unsigned int cmd,void *arg);void snd_pcm_period_elapsed_under_stream_lock (struct snd_pcm_substream *substream);
sound/core/pcm_lib.c +24 -5
@@ -1766,20 +1766,39 @@ }EXPORT_SYMBOL (snd_pcm_hw_params_bits); -static int snd_pcm_lib_ioctl_reset (struct snd_pcm_substream *substream, -void *arg) +/** +* snd_pcm_lib_reset - Reset the pointer while holding the PCM stream lock +* @substream: PCM substream +* +* Context: PCM stream lock held. The caller must not hold driver locks +* acquired by the pointer or XRUN callbacks. +* +* Update a running stream through the ordinary pointer path. Other states +* start at zero. Pointer errors keep the existing RESET return semantics; +* a zero return does not imply recovery from XRUN. +* This helper does not update appl_ptr or acquire the stream lock. +* +* Return: zero. +*/ +int snd_pcm_lib_reset (struct snd_pcm_substream *substream) {struct snd_pcm_runtime *runtime = substream->runtime; -guard (pcm_stream_lock_irqsave)(substream); -if (snd_pcm_running (substream) && -snd_pcm_update_hw_ptr (substream) >=0 ) +if (snd_pcm_running (substream) &&snd_pcm_update_hw_ptr (substream) >=0 ) runtime->status->hw_ptr %= runtime->buffer_size;else { runtime->status->hw_ptr =0 ; runtime->hw_ptr_wrap =0 ; }return 0 ; +} +EXPORT_SYMBOL (snd_pcm_lib_reset); + +static int snd_pcm_lib_ioctl_reset (struct snd_pcm_substream *substream, +void *arg) +{ +guard (pcm_stream_lock_irqsave)(substream); +return snd_pcm_lib_reset (substream); } static int snd_pcm_lib_ioctl_channel_info(struct snd_pcm_substream *substream,
sound/core/pcm_native.c +40 -5
75 lines not on this page · raw message
PATCH v30 5/17 ALSA: pcm: serialize linked buffer actions
In reply to Joonho LeeConcurrent non-atomic actions on different members of a linked PCM group currently lock their own buffer first, then the other members. That acquisition order can differ between callers. Sibling buffer mutexes also do not close their buffer-access admission counters.
Close buffer access for every member before taking any buffer mutex, and acquire those mutexes in the stable linked-list order while group membership is protected. Release every access gate on success and on failure, including when a member already has an active buffer access. The group action then uses the buffers already held by its caller.
The PCM stream and group locks are not held across sleeping driver prepare callbacks. Single-stream non-atomic actions keep their existing buffer-access locking path.
---sound/core/pcm_native.c | 71 +++++++++++++++++++++++++++++++++++++----------
1 file changed, 56 insertions(+), 15 deletions(-)
sound/core/pcm_native.c +56 -15
@@ -731,6 +731,44 @@ {mutex_unlock (&runtime->buffer_mutex);atomic_inc (&runtime->buffer_accessing); +} + +/* Gate all linked buffers before taking their mutexes in group-list order. */ +static int snd_pcm_group_buffer_access_lock (struct snd_pcm_substream *substream) +{ +struct snd_pcm_substream *s, *s1; +int depth =0 ; + +snd_pcm_group_for_each_entry (s, substream) { +if (!atomic_dec_unless_positive (&s->runtime->buffer_accessing)) { +snd_pcm_group_for_each_entry (s1, substream) { +if (s1 == s) +break ; +atomic_inc (&s1->runtime->buffer_accessing); + } +return -EBUSY ; + } + } + +snd_pcm_group_for_each_entry (s, substream) { +if (depth ==0 ) +mutex_lock (&s->runtime->buffer_mutex); +else +mutex_lock_nested (&s->runtime->buffer_mutex, depth); + depth++; + } + +return 0 ; +} + +static void snd_pcm_group_buffer_access_unlock (struct snd_pcm_substream *substream) +{ +struct snd_pcm_substream *s; + +list_for_each_entry_reverse (s, &substream->group->substreams, link_list) +mutex_unlock (&s->runtime->buffer_mutex); +snd_pcm_group_for_each_entry (s, substream) +atomic_inc (&s->runtime->buffer_accessing); }/* fill the PCM buffer with the current silence format; called from pcm_oss.c */
@@ -1317,9 +1355,9 @@ };/* -* this functions is core for handling of linked stream -* Note: the stream state might be changed also on failure -* Note2: call with calling stream lock + link lock +* Handle an action on all linked streams. +* When stream_lock is true, the caller holds the calling stream and group +* locks. Otherwise, the caller holds link_rwsem and every group buffer_mutex. */ static int snd_pcm_action_group(const struct action_ops *ops, struct snd_pcm_substream *substream,
@@ -1331,10 +1369,8 @@int res =0 , depth =1 ;snd_pcm_group_for_each_entry (s, substream) { -if (s != substream) { -if (!stream_lock) -mutex_lock_nested (&s->runtime->buffer_mutex, depth); -else if (s->pcm->nonatomic) +if (s != substream && stream_lock) { +if (s->pcm->nonatomic)mutex_lock_nested (&s->self_group.mutex, depth);else spin_lock_nested (&s->self_group.lock, depth);
@@ -1371,10 +1407,8 @@ _unlock:/* unlock streams */ snd_pcm_group_for_each_entry (s1, substream) { -if (s1 != substream) { -if (!stream_lock) -mutex_unlock (&s1->runtime->buffer_mutex); -else if (s1->pcm->nonatomic) +if (s1 != substream && stream_lock) { +if (s1->pcm->nonatomic)mutex_unlock (&s1->self_group.mutex);else spin_unlock (&s1->self_group.lock);
@@ -1512,18 +1546,25 @@struct snd_pcm_substream *substream, snd_pcm_state_t state) { + bool linked;int res;/* Guarantee the group members won't change during non-atomic action */ guard (rwsem_read)(&snd_pcm_link_rwsem); - res =snd_pcm_buffer_access_lock (substream->runtime); + linked =snd_pcm_stream_linked (substream); +if (linked) + res =snd_pcm_group_buffer_access_lock (substream); +else + res =snd_pcm_buffer_access_lock (substream->runtime);if (res <0 )return res; -if (snd_pcm_stream_linked (substream)) +if (linked) { res =snd_pcm_action_group (ops, substream, state, false); -else +snd_pcm_group_buffer_access_unlock (substream); + }else { res =snd_pcm_action_single (ops, substream, state, false); -snd_pcm_buffer_access_unlock (substream->runtime); +snd_pcm_buffer_access_unlock (substream->runtime); + }return res; }
PATCH v30 6/17 ALSA: virtio: propagate playback send failures through ACK
In reply to Joonho LeePropagate playback submission failures through ACK and commit indirect accounting only after transport submission succeeds. Keep the PCM state and buffer-access checks synchronized with playback transfer admission. The existing capture ACK callback and initial queue reservation behavior remain together until the request-owned capture conversion in patch 12. That conversion introduces RX reservation, validation and refill as one contract.
---sound/virtio/virtio_pcm.h | 6 +
sound/virtio/virtio_pcm_msg.c | 12 ++ sound/virtio/virtio_pcm_ops.c | 237 ++++++++++++++++++++++++++++++++++++----- 3 files changed, 228 insertions(+), 27 deletions(-)
sound/virtio/virtio_pcm.h +6 -0
@@ -33,6 +33,10 @@* @xfer_xrun: Data underflow/overflow state (0 - no xrun, 1 - xrun). * @stopped: True if the substream is stopped and must be released on the device * side. +* @prepared: True after device PREPARE and the core pointer reset succeed; +* protected by @lock. +* @preparing: ACK gate through teardown and prepare's core reset; +* protected by @lock. * @suspended: True if the substream is suspended and must be reconfigured on * the device side at resume. * @msgs: Allocated I/O messages.
@@ -56,6 +60,8 @@bool xfer_enabled;bool xfer_xrun;bool stopped; +bool prepared; +bool preparing;bool suspended;struct virtio_pcm_msg **msgs;unsigned int nmsgs;
sound/virtio/virtio_pcm_msg.c +12 -0
@@ -260,6 +260,18 @@dev_err (&vdev->dev,"SID %u: failed to send I/O message\n" , vss->sid); + msg->length -= n; + +/* +* Do not leave earlier messages queued without notifying +* the device when a later message could not be added. +*/ +if (msg_count != vss->msg_count && + !(vss->features & + (1U <<VIRTIO_SND_PCM_F_MSG_POLLING )) && +virtqueue_kick_prepare (vqueue)) +virtqueue_notify (vqueue); +return rc; }
sound/virtio/virtio_pcm_ops.c +210 -27
368 lines not on this page · raw message
PATCH v30 7/17 ALSA: virtio: Recover PCM state after a failed start
In reply to Joonho LeeCapture trigger queues I/O messages before PCM_START. If the START message cannot be allocated or sent, transfers may remain queued, and ALSA does not invoke the action undo callback for the failed trigger.
Mark the stream stopped and disable transfers for every failed START path. Arm runtime->stop_operating so sync_stop releases pending I/O and prevents prepare, hw_params, or START retries until release succeeds.
Latch a transfer XRUN in both playback and capture, and schedule the existing period worker so a running or draining core stream sees the pointer error. This also retires a failed playback START during drain, where drain-init can already have advanced the core state to DRAINING.
The stopped flag is shared with ACK callbacks that can run without the ALSA stream lock. Protect every stopped access with vss->lock. Read the pending message count under the same lock in open and hw_params. In sync_stop, decide whether RELEASE is needed and mark the stream stopped in one locked transition; leave it stopped when release or draining fails.
Always cancel elapsed-period work in sync_stop, even when no RELEASE is needed.
Record the RELEASE obligation after successful PREPARE and clear it as soon as RELEASE succeeds. If the subsequent RX wait fails, retry that wait without submitting RELEASE again.
---sound/virtio/virtio_pcm.h | 6 +-
sound/virtio/virtio_pcm_ops.c | 113 +++++++++++++++++++++++++++++++---------- 2 files changed, 89 insertions(+), 30 deletions(-)
sound/virtio/virtio_pcm.h +4 -2
@@ -26,13 +26,13 @@* @hw: Kernel ALSA substream hardware descriptor. * @elapsed_period: Kernel work to handle the elapsed period state. * @lock: Spinlock that protects fields shared by interrupt handlers and -* substream operators. +* substream operators, including @stopped. * @buffer_bytes: Current buffer size in bytes. * @hw_ptr: Substream hardware pointer value in bytes [0 ... buffer_bytes). * @xfer_enabled: Data transfer state (0 - off, 1 - on). * @xfer_xrun: Data underflow/overflow state (0 - no xrun, 1 - xrun). * @stopped: True if the substream is stopped and must be released on the device -* side. +* side; protected by @lock. * @prepared: True after device PREPARE and the core pointer reset succeed; * protected by @lock. * @preparing: ACK gate through teardown and prepare's core reset;
@@ -62,6 +62,8 @@bool stopped;bool prepared;bool preparing; +/* Successful PREPARE still needs RELEASE; protected by lock. */ +bool release_required;bool suspended;struct virtio_pcm_msg **msgs;unsigned int nmsgs;
sound/virtio/virtio_pcm_ops.c +85 -28
189 lines not on this page · raw message
PATCH v30 8/17 ALSA: virtio: Retain queued messages through device reset
In reply to Joonho LeeKeep the control queue available through snd_card_free() so close-time STOP and RELEASE commands can still be submitted. Block new control requests and mark pending messages canceled before reset, then release their queue references only after reset and queue deletion.
For PCM queues, detach each remaining virtqueue buffer after the device has stopped DMA and retire its message without reporting a normal completion. Detach all queues before deleting them so outstanding DMA mappings are unmapped and no token remains for a late device completion.
Protect event callback admission with the event queue lock. Disabling events waits for an active dispatch, and later callbacks see a closed gate before ALSA objects are freed. Enable and pending-event draining share the same lock.
Reclaim pending event buffers after a failed probe without dispatching notifications into ALSA objects that have not been constructed. Record the queue's prior enabled state under its lock before closing admission.
Track successful virtqueue initialization so teardown and failed restore cleanup call del_vqs() only for an initialized queue set.
---sound/virtio/virtio_card.c | 110 ++++++++++++++++++++++++++++++++---------
sound/virtio/virtio_card.h | 6 ++ sound/virtio/virtio_ctl_msg.c | 64 +++++++++++++++++++++--- sound/virtio/virtio_ctl_msg.h | 4 + sound/virtio/virtio_pcm.h | 2 + sound/virtio/virtio_pcm_msg.c | 42 ++++++++++++++-- 6 files changed, 193 insertions(+), 35 deletions(-)
sound/virtio/virtio_card.c +86 -24
@@ -70,23 +70,13 @@ } } -/** -* virtsnd_event_notify_cb() - Dispatch all reported events from the event queue. -* @vqueue: Underlying event virtqueue. -* -* This callback function is called upon a vring interrupt request from the -* device. -* -* Context: Interrupt context. -*/ -static void virtsnd_event_notify_cb (struct virtqueue *vqueue) -{ -struct virtio_snd *snd = vqueue->vdev->priv; -struct virtio_snd_queue *queue =virtsnd_event_queue (snd); +static void virtsnd_event_drain_locked (struct virtio_snd *snd, +struct virtqueue *vqueue) +{struct virtio_snd_event *event;u32 length; -guard (spinlock_irqsave)(&queue->lock); +lockdep_assert_held (&virtsnd_event_queue (snd)->lock); do { virtqueue_disable_cb(vqueue); while ((event = virtqueue_get_buf(vqueue, &length))) {
@@ -94,6 +84,26 @@virtsnd_event_send (vqueue, event, true,GFP_ATOMIC ); } }while (!virtqueue_enable_cb (vqueue)); +} + +/** +* virtsnd_event_notify_cb() - Dispatch all reported events from the event queue. +* @vqueue: Underlying event virtqueue. +* +* This callback function is called upon a vring interrupt request from the +* device. +* +* Context: Interrupt context. +*/ +static void virtsnd_event_notify_cb (struct virtqueue *vqueue) +{ +struct virtio_snd *snd = vqueue->vdev->priv; +struct virtio_snd_queue *queue =virtsnd_event_queue (snd); + +guard (spinlock_irqsave)(&queue->lock); +if (queue->vqueue != vqueue || !snd->event_vq_enabled) +return ; +virtsnd_event_drain_locked (snd, vqueue); }/**
@@ -131,6 +141,7 @@for (i =0 ; i <VIRTIO_SND_VQ_MAX ; ++i) snd->queues[i].vqueue = vqs[i]; + snd->vqs_initialized = true;/* Allocate events and populate the event queue */ virtqueue_disable_cb (vqs[VIRTIO_SND_VQ_EVENT ]);
@@ -158,8 +169,12 @@ {struct virtio_snd_queue *queue =virtsnd_event_queue (snd); +guard (spinlock_irqsave)(&queue->lock); +if (!queue->vqueue) +return ; + snd->event_vq_enabled = true;if (!virtqueue_enable_cb (queue->vqueue)) -virtsnd_event_notify_cb (queue->vqueue); +virtsnd_event_drain_locked (snd, queue->vqueue); }/**
@@ -172,13 +187,19 @@ {struct virtio_snd_queue *queue =virtsnd_event_queue (snd);struct virtio_snd_event *event; +bool dispatch_events;u32 length; +guard (spinlock_irqsave)(&queue->lock); + dispatch_events = snd->event_vq_enabled; + snd->event_vq_enabled = false;if (queue->vqueue) { -guard (spinlock_irqsave)(&queue->lock);virtqueue_disable_cb (queue->vqueue); -while ((event =virtqueue_get_buf (queue->vqueue, &length))) -virtsnd_event_dispatch (snd, event); +while ((event =virtqueue_get_buf (queue->vqueue, &length))) { +/* Reclaim used buffers even when failed probe cannot dispatch. */ +if (dispatch_events) +virtsnd_event_dispatch (snd, event); + } } }
@@ -338,6 +359,43 @@ }/** +* virtsnd_reset_vqs() - Stop device access and unmap outstanding buffers. +* @snd: VirtIO sound device. +* +* Context: Any context that permits to sleep. +*/ +static void virtsnd_reset_vqs (struct virtio_snd *snd) +{ +struct virtio_device *vdev = snd->vdev; +unsigned int i; + +virtio_reset_device (vdev); + +/* Deleting a virtqueue does not unmap its outstanding descriptors. */ +for (i =0 ; i <VIRTIO_SND_VQ_MAX ; ++i) { +struct virtio_snd_queue *queue = &snd->queues[i]; +unsigned long flags; +void *msg; + +spin_lock_irqsave (&queue->lock, flags); +if (queue->vqueue) +while ((msg =virtqueue_detach_unused_buf (queue->vqueue))) +if (i ==VIRTIO_SND_VQ_TX || i ==VIRTIO_SND_VQ_RX ) +virtsnd_pcm_msg_cancel (msg); +if (i ==VIRTIO_SND_VQ_EVENT ) + snd->event_vq_enabled = false; +/* IRQ callbacks must never see a detached ring as live. */ + queue->vqueue =NULL ; +spin_unlock_irqrestore (&queue->lock, flags); + } + +if (snd->vqs_initialized) { + vdev->config->del_vqs (vdev); + snd->vqs_initialized = false; + } +} + +/** * virtsnd_remove() - Remove VirtIO and ALSA devices. * @vdev: VirtIO parent device. *
@@ -349,13 +407,14 @@unsigned int i;virtsnd_disable_event_vq (snd); -virtsnd_ctl_msg_cancel_all (snd);if (snd->card)snd_card_free (snd->card); -virtio_reset_device (vdev); - vdev->config->del_vqs (vdev); +virtsnd_ctl_msg_cancel_all (snd); + +virtsnd_reset_vqs (snd); +virtsnd_ctl_msg_cleanup (snd);for (i =0 ; snd->substreams && i < snd->nsubstreams; ++i) {struct virtio_pcm_substream *vss = &snd->substreams[i];
@@ -383,8 +442,8 @@virtsnd_disable_event_vq (snd);virtsnd_ctl_msg_cancel_all (snd); -virtio_reset_device (vdev); - vdev->config->del_vqs (vdev); +virtsnd_reset_vqs (snd); +virtsnd_ctl_msg_cleanup (snd);for (i =0 ; i < snd->nsubstreams; ++i)cancel_work_sync (&snd->substreams[i].elapsed_period);
@@ -408,10 +467,13 @@int rc; rc =virtsnd_find_vqs (snd); -if (rc) +if (rc) { +virtsnd_reset_vqs (snd);return rc; + }virtio_device_ready (vdev); +virtsnd_ctl_msg_enable (snd);virtsnd_enable_event_vq (snd);
sound/virtio/virtio_card.h +6 -0
@@ -45,8 +45,11 @@* struct virtio_snd - VirtIO sound card device. * @vdev: Underlying virtio device. * @queues: Virtqueue wrappers. +* @vqs_initialized: Virtqueues allocated by virtio_find_vqs(). * @card: ALSA sound card. * @ctl_msgs: Pending control request list. +* @ctl_msgs_blocked: Control requests are blocked during teardown or suspend. +* @event_vq_enabled: Event callbacks may dispatch, protected by the event queue lock. * @event_msgs: Device events. * @pcm_list: VirtIO PCM device list. * @jacks: VirtIO jacks.
@@ -62,8 +65,11 @@struct virtio_snd {struct virtio_device *vdev;struct virtio_snd_queue queues[VIRTIO_SND_VQ_MAX ]; +bool vqs_initialized;struct snd_card *card;struct list_head ctl_msgs; +bool ctl_msgs_blocked; +bool event_vq_enabled;struct virtio_snd_event *event_msgs;struct list_head pcm_list;struct virtio_jack *jacks;
sound/virtio/virtio_ctl_msg.c +57 -7
130 lines not on this page · raw message
sound/virtio/virtio_ctl_msg.h +4 -0
@@ -68,6 +68,10 @@void virtsnd_ctl_msg_cancel_all (struct virtio_snd *snd); +void virtsnd_ctl_msg_cleanup (struct virtio_snd *snd); + +void virtsnd_ctl_msg_enable (struct virtio_snd *snd); +void virtsnd_ctl_msg_complete (struct virtio_snd_msg *msg); int virtsnd_ctl_query_info(struct virtio_snd *snd, int command, int start_id,
sound/virtio/virtio_pcm.h +2 -0
@@ -128,6 +128,8 @@void virtsnd_pcm_msg_reset (struct virtio_pcm_substream *vss); +void virtsnd_pcm_msg_cancel (struct virtio_pcm_msg *msg); +int virtsnd_pcm_msg_send (struct virtio_pcm_substream *vss,unsigned long offset,unsigned long bytes);
sound/virtio/virtio_pcm_msg.c +38 -4
74 lines not on this page · raw message
PATCH v30 9/17 ALSA: virtio: bound PCM transfers and retain DMA buffers
In reply to Joonho LeeValidate ACK geometry, conversion bounds and queued-byte accounting before submitting transfers. Retain the backing DMA pages until message retirement. Check RX status and upper payload bounds while accepting bounded short responses, including at STOP and PAUSE. Preserve the legacy RX completion and ACK policy until the request-owned conversion, including the legacy handling of empty PAUSE returns. The fixed-offset layout still has short-response data gaps; request-owned capture and its queue/accounting contract arrive together in patch 12. Non-MMU copies use only the validated returned payload length.
---
sound/virtio/virtio_pcm.h | 11 + sound/virtio/virtio_pcm_msg.c | 306 +++++++++++++++++++++++++++++++++++------ sound/virtio/virtio_pcm_ops.c | 113 +++++++++++++++ 3 files changed, 386 insertions(+), 44 deletions(-)
sound/virtio/virtio_pcm.h +11 -0
@@ -13,6 +13,7 @@struct virtio_pcm ;struct virtio_pcm_msg ; +struct page ;/** * struct virtio_pcm_substream - VirtIO PCM substream.
@@ -42,6 +43,10 @@* @msgs: Allocated I/O messages. * @nmsgs: Number of allocated I/O messages. * @msg_count: Number of pending I/O messages in the virtqueue. +* @dma_pages: Pages backing DMA messages, retained until messages are freed. +* @ndma_pages: Number of retained pages. +* @owned_dma_area: Driver-owned PCM buffer backing asynchronous messages. +* @owned_dma_bytes: Size of @owned_dma_area. * @msg_empty: Notify when msg_count is zero. */ struct virtio_pcm_substream {
@@ -68,6 +73,12 @@struct virtio_pcm_msg **msgs;unsigned int nmsgs;unsigned int msg_count; +struct page **dma_pages; +unsigned int ndma_pages; +#ifndef CONFIG_MMU +u8 *owned_dma_area; +size_t owned_dma_bytes; +#endif wait_queue_head_t msg_empty; };
sound/virtio/virtio_pcm_msg.c +263 -43
413 lines not on this page · raw message
sound/virtio/virtio_pcm_ops.c +112 -1
141 lines not on this page · raw message
PATCH v30 10/17 ALSA: virtio: Keep control payloads alive through DMA completion
In reply to Joonho LeeControl requests can expose caller-owned payloads to the device after a synchronous send times out. Keep request and response headers and payloads in the reference-counted message so caller cleanup cannot invalidate DMA.
Keep the queue reference until device completion or post-reset cleanup, even when the caller times out or is interrupted. Consume the caller's reference on every send path, and let response readers retain an extra reference through copyout. Check payload sizes and allocation arithmetic before building the scatterlists.
A control value payload is also read by the CPU as a typed structure. DMA cacheline alignment alone does not guarantee the structure's CPU alignment. Align regions to the greater of the DMA cacheline and control-value type alignment, and reserve prefix slack from the buffer base so typed accesses remain aligned while scatterlist regions stay on cacheline boundaries.
Keep response values in a separately allocated aligned response buffer so INTEGER64 control accesses are aligned from this patch onward.
---sound/virtio/virtio_ctl_msg.c | 289 +++++++++++++++++++++++++++++++----------
sound/virtio/virtio_ctl_msg.h | 24 ++- sound/virtio/virtio_kctl.c | 121 +++++++++-------- sound/virtio/virtio_pcm_msg.c | 2 4 files changed, 300 insertions(+), 136 deletions(-)
sound/virtio/virtio_ctl_msg.c +218 -71
@@ -3,7 +3,10 @@* virtio-snd: Virtio sound device * Copyright (C) 2021 OpenSynergy GmbH */ +#include <linux/dma-mapping.h> +#include <linux/limits.h> #include <linux/moduleparam.h> +#include <linux/overflow.h> #include <linux/virtio_config.h> #include "virtio_card.h"
@@ -11,7 +14,12 @@/** * struct virtio_snd_msg - Control message. * @sg_request: Scattergather list containing a device request (header). +* @sg_request_data: Scattergather list containing request data. * @sg_response: Scattergather list containing a device response (status). +* @sg_response_data: Scattergather list containing response data. +* @dma_buffer: Message-owned storage for all DMA-visible SG regions. +* @request_data_size: Size of the request data buffer. +* @response_data_size: Size of the response data buffer. * @list: Pending message list entry. * @notify: Request completed notification. * @ref_count: Reference count used to manage a message lifetime.
@@ -19,7 +27,12 @@*/ struct virtio_snd_msg {struct scatterlist sg_request; +struct scatterlist sg_request_data;struct scatterlist sg_response; +struct scatterlist sg_response_data; +void *dma_buffer; +size_t request_data_size; +size_t response_data_size;struct list_head list;struct completion notify;refcount_t ref_count;
@@ -47,8 +60,10 @@*/ void virtsnd_ctl_msg_unref (struct virtio_snd_msg *msg) { -if (refcount_dec_and_test (&msg->ref_count)) +if (refcount_dec_and_test (&msg->ref_count)) { +kfree (msg->dma_buffer);kfree (msg); + } }/**
@@ -71,12 +86,73 @@void *virtsnd_ctl_msg_response (struct virtio_snd_msg *msg) {return sg_virt (&msg->sg_response); +} + +/** +* virtsnd_ctl_msg_request_data() - Get the request data buffer. +* @msg: Control message. +* +* Context: Any context. +*/ +void *virtsnd_ctl_msg_request_data (struct virtio_snd_msg *msg) +{ +return msg->request_data_size ?sg_virt (&msg->sg_request_data) :NULL ; +} + +/** +* virtsnd_ctl_msg_response_data() - Get the response data buffer. +* @msg: Control message. +* +* Context: Any context. +*/ +void *virtsnd_ctl_msg_response_data (struct virtio_snd_msg *msg) +{ +return msg->response_data_size ?sg_virt (&msg->sg_response_data) :NULL ; +} + +/** +* virtsnd_ctl_msg_sg_init() - Place one DMA region on cacheline boundaries. +* @sg: Scattergather entry for the region. +* @cursor: Current location in the message-owned DMA buffer. +* @size: Region length. +* @alignment: Alignment for DMA cachelines and typed CPU accesses. +* +* Context: Any context during message allocation. +* Return: 0 on success, -EOVERFLOW if the address cannot be represented. +*/ +static int virtsnd_ctl_msg_sg_init (struct scatterlist *sg,u8 **cursor, +size_t size,size_t alignment) +{ +uintptr_t address = (uintptr_t )*cursor; +uintptr_t end; +size_t padding; + + padding = address % alignment; +if (padding && +check_add_overflow (address, (uintptr_t )(alignment - padding), + &address)) +return -EOVERFLOW ; + +if (check_add_overflow (address, (uintptr_t )size, &end)) +return -EOVERFLOW ; + + padding = end % alignment; +if (padding && +check_add_overflow (end, (uintptr_t )(alignment - padding), &end)) +return -EOVERFLOW ; + +sg_init_one (sg, (void *)address, (unsigned int )size); + *cursor = (u8 *)end; + +return 0 ; }/** * virtsnd_ctl_msg_alloc() - Allocate and initialize a control message. * @request_size: Size of request header. * @response_size: Size of response header. +* @request_data_size: Size of request data buffer. +* @response_data_size: Size of response data buffer. * @gfp: Kernel flags for memory allocation. * * The message will be automatically freed when the ref_count value is 0.
@@ -85,20 +161,85 @@* Return: Allocated message on success, NULL on failure. */ struct virtio_snd_msg *virtsnd_ctl_msg_alloc (size_t request_size, -size_t response_size,gfp_t gfp) +size_t response_size, +size_t request_data_size, +size_t response_data_size, +gfp_t gfp) {struct virtio_snd_msg *msg; - -if (!request_size || !response_size) +struct scatterlist *sgs[4 ]; +size_t sizes[4 ] = { + request_size, + response_size, + request_data_size, + response_data_size, + }; +size_t alignment; +size_t dma_buffer_size; +size_t aligned_size; +size_t padding; +u8 *data; +unsigned int i; +int cache_alignment; +int rc; + +if (!request_size || !response_size || request_size >UINT_MAX || + response_size >UINT_MAX || request_data_size >UINT_MAX || + response_data_size >UINT_MAX )return NULL ; - - msg =kzalloc (sizeof (*msg) + request_size + response_size, gfp); + cache_alignment =dma_get_cache_alignment (); +if (cache_alignment <=0 ) +return NULL ; +/* DMA coherence does not remove the CPU's type alignment requirement. */ + alignment =max_t (size_t, cache_alignment, + __alignof__(struct virtio_snd_ctl_value )); + +/* Reserve prefix alignment slack before the first DMA region. */ + dma_buffer_size = alignment -1 ; +for (i =0 ; i <ARRAY_SIZE (sizes); ++i) { +if (!sizes[i]) +continue ; + + padding = sizes[i] % alignment; + aligned_size = sizes[i]; +if (padding && +check_add_overflow (aligned_size, alignment - padding, + &aligned_size)) +return NULL ; + +if (check_add_overflow (dma_buffer_size, aligned_size, + &dma_buffer_size)) +return NULL ; + } + + msg =kzalloc (sizeof (*msg), gfp);if (!msg)return NULL ; -sg_init_one (&msg->sg_request, (u8 *)msg +sizeof (*msg), request_size); -sg_init_one (&msg->sg_response, (u8 *)msg +sizeof (*msg) + request_size, - response_size); + msg->dma_buffer =kzalloc (dma_buffer_size, gfp); +if (!msg->dma_buffer) { +kfree (msg); +return NULL ; + } + data = msg->dma_buffer; + sgs[0 ] = &msg->sg_request; + sgs[1 ] = &msg->sg_response; + sgs[2 ] = &msg->sg_request_data; + sgs[3 ] = &msg->sg_response_data; +for (i =0 ; i <ARRAY_SIZE (sizes); ++i) { +if (!sizes[i]) +continue ; + + rc =virtsnd_ctl_msg_sg_init (sgs[i], &data, sizes[i], alignment); +if (rc) { +kfree (msg->dma_buffer); +kfree (msg); +return NULL ; + } + } + + msg->request_data_size = request_data_size; + msg->response_data_size = response_data_size;INIT_LIST_HEAD (&msg->list);init_completion (&msg->notify);
@@ -112,17 +253,15 @@* virtsnd_ctl_msg_send() - Send a control message. * @snd: VirtIO sound device. * @msg: Control message. -* @out_sgs: Additional sg-list to attach to the request header (may be NULL). -* @in_sgs: Additional sg-list to attach to the response header (may be NULL). * @nowait: Flag indicating whether to wait for completion. * * Context: Any context. Takes and releases the control queue spinlock. * May sleep if @nowait is false. +* Consumes the caller's reference on every return path. * Return: 0 on success, -errno on failure. */ int virtsnd_ctl_msg_send (struct virtio_snd *snd,struct virtio_snd_msg *msg, -struct scatterlist *out_sgs, -struct scatterlist *in_sgs,bool nowait) +bool nowait) {struct virtio_device *vdev = snd->vdev;struct virtio_snd_queue *queue =virtsnd_control_queue (snd);
@@ -133,6 +272,7 @@unsigned int nins =0 ;struct scatterlist *psgs[4 ];bool notify = false; +unsigned long flags;int rc;virtsnd_ctl_msg_ref (msg);
@@ -142,27 +282,27 @@ response->code =cpu_to_le32 (VIRTIO_SND_S_IO_ERR ); psgs[nouts++] = &msg->sg_request; -if (out_sgs) - psgs[nouts++] = out_sgs; +if (msg->request_data_size) + psgs[nouts++] = &msg->sg_request_data; psgs[nouts + nins++] = &msg->sg_response; -if (in_sgs) - psgs[nouts + nins++] = in_sgs; - - scoped_guard(spinlock_irqsave, &queue->lock) { -if (snd->ctl_msgs_blocked) - rc = -ENODEV ; -else - rc =virtqueue_add_sgs (queue->vqueue, psgs, nouts, nins, - msg,GFP_ATOMIC ); -if (!rc) { - notify =virtqueue_kick_prepare (queue->vqueue); - -list_add_tail (&msg->list, &snd->ctl_msgs); -if (notify) -virtqueue_notify (queue->vqueue); - } - } +if (msg->response_data_size) + psgs[nouts + nins++] = &msg->sg_response_data; + +spin_lock_irqsave (&queue->lock, flags); +if (snd->ctl_msgs_blocked) + rc = -ENODEV ; +else + rc =virtqueue_add_sgs (queue->vqueue, psgs, nouts, nins, msg, +GFP_ATOMIC ); +if (!rc) { + notify =virtqueue_kick_prepare (queue->vqueue); + +list_add_tail (&msg->list, &snd->ctl_msgs); +if (notify) +virtqueue_notify (queue->vqueue); + } +spin_unlock_irqrestore (&queue->lock, flags);if (rc) { dev_err(&vdev->dev, "failed to send control message (0x%08x)\n",
@@ -173,46 +313,36 @@* called, it is necessary to decrement the reference count. */ virtsnd_ctl_msg_unref (msg); - - goto on_exit; - } - -if (nowait) - goto on_exit; - - rc =wait_for_completion_interruptible_timeout (&msg->notify, js); -if (rc <=0 ) { + }else if (!nowait) { + rc =wait_for_completion_interruptible_timeout (&msg->notify, js);if (!rc) {dev_err (&vdev->dev,"control message (0x%08x) timeout\n" ,le32_to_cpu (request->code)); rc = -ETIMEDOUT ; + }else if (rc >0 ) { +if (READ_ONCE (msg->cancelled)) { + rc = -ENODEV ; + }else { +switch (le32_to_cpu (response->code)) { +case VIRTIO_SND_S_OK : + rc =0 ; +break ; +case VIRTIO_SND_S_NOT_SUPP : + rc = -EOPNOTSUPP ; +break ; +case VIRTIO_SND_S_IO_ERR : + rc = -EIO ; +break ; +default : + rc = -EINVAL ; +break ; + } + } } - - goto on_exit; - } - -if (READ_ONCE (msg->cancelled)) { - rc = -ENODEV ; - goto on_exit; - } - -switch (le32_to_cpu (response->code)) { -case VIRTIO_SND_S_OK : - rc =0 ; -break ; -case VIRTIO_SND_S_NOT_SUPP : - rc = -EOPNOTSUPP ; -break ; -case VIRTIO_SND_S_IO_ERR : - rc = -EIO ; -break ; -default : - rc = -EINVAL ; -break ; - } - -on_exit: + } + +/* Drop the reference consumed by this send attempt. */ virtsnd_ctl_msg_unref (msg);return rc;
@@ -308,10 +438,23 @@ {struct virtio_snd_msg *msg;struct virtio_snd_query_info *query; -struct scatterlist sg; +size_t info_size; +int rc; + +if (count <0 ) +return -EINVAL ; + +if (size >UINT_MAX || +check_mul_overflow ((size_t )count, size, &info_size) || + info_size >UINT_MAX ) +return -EOVERFLOW ; + +if (info_size && !info) +return -EINVAL ; msg =virtsnd_ctl_msg_alloc (sizeof (*query), -sizeof (struct virtio_snd_hdr ),GFP_KERNEL ); +sizeof (struct virtio_snd_hdr ),0 , info_size, +GFP_KERNEL );if (!msg)return -ENOMEM ;
@@ -321,9 +464,13 @@ query->count =cpu_to_le32 (count); query->size =cpu_to_le32 (size); -sg_init_one (&sg, info, count * size); - -return virtsnd_ctl_msg_send (snd, msg,NULL , &sg, false); +virtsnd_ctl_msg_ref (msg); + rc =virtsnd_ctl_msg_send (snd, msg, false); +if (!rc && info_size) +memcpy (info,virtsnd_ctl_msg_response_data (msg), info_size); +virtsnd_ctl_msg_unref (msg); + +return rc; }/**
sound/virtio/virtio_ctl_msg.h +16 -8
@@ -21,20 +21,28 @@void *virtsnd_ctl_msg_response (struct virtio_snd_msg *msg);struct virtio_snd_msg *virtsnd_ctl_msg_alloc (size_t request_size, -size_t response_size,gfp_t gfp); +size_t response_size, +size_t request_data_size, +size_t response_data_size, +gfp_t gfp); + +void *virtsnd_ctl_msg_request_data (struct virtio_snd_msg *msg); + +void *virtsnd_ctl_msg_response_data (struct virtio_snd_msg *msg);int virtsnd_ctl_msg_send (struct virtio_snd *snd,struct virtio_snd_msg *msg, -struct scatterlist *out_sgs, -struct scatterlist *in_sgs,bool nowait); +bool nowait);/** * virtsnd_ctl_msg_send_sync() - Simplified sending of synchronous message. * @snd: VirtIO sound device. * @msg: Control message. * -* After returning from this function, the message will be deleted. If message -* content is still needed, the caller must additionally to -* virtsnd_ctl_msg_ref/unref() it. +* This function consumes the caller's message reference on return. A message +* accepted by the control queue keeps its queue reference until completion or +* post-reset cleanup, including when this function returns on timeout or +* interruption. Callers that read the response after success must retain an +* additional reference through that access. * * The msg_timeout_ms module parameter defines the message completion timeout. * If the message is not completed within this time, the function will return an
@@ -49,7 +57,7 @@static inline int virtsnd_ctl_msg_send_sync (struct virtio_snd *snd,struct virtio_snd_msg *msg) { -return virtsnd_ctl_msg_send (snd, msg,NULL ,NULL , false); +return virtsnd_ctl_msg_send (snd, msg, false); }/**
@@ -63,7 +71,7 @@static inline int virtsnd_ctl_msg_send_async (struct virtio_snd *snd,struct virtio_snd_msg *msg) { -return virtsnd_ctl_msg_send (snd, msg,NULL ,NULL , true); +return virtsnd_ctl_msg_send (snd, msg, true); }void virtsnd_ctl_msg_cancel_all (struct virtio_snd *snd);
sound/virtio/virtio_kctl.c +65 -56
192 lines not on this page · raw message
sound/virtio/virtio_pcm_msg.c +1 -1
@@ -688,7 +688,7 @@break ; } - msg =virtsnd_ctl_msg_alloc (request_size, response_size, gfp); + msg =virtsnd_ctl_msg_alloc (request_size, response_size,0 ,0 , gfp);if (msg) {struct virtio_snd_pcm_hdr *hdr =virtsnd_ctl_msg_request (msg);
PATCH v30 11/17 ALSA: virtio: wait through signals for PCM teardown
In reply to Joonho LeeA signal can end the interruptible wait while a STOP or RELEASE request is still pending. A later teardown may then submit another RELEASE before the first request completes.
Keep both waits non-interruptible and use the existing message timeout. Other control requests remain interruptible. Device reset still cancels the pending request and wakes the waiter.
Keep timeout and wait results in the types returned by the kernel wait APIs.
---sound/virtio/virtio_ctl_msg.c | 19 ++++++++++++++++---
sound/virtio/virtio_ctl_msg.h | 3 +++ sound/virtio/virtio_pcm_ops.c | 10 +++++----- 3 files changed, 24 insertions(+), 8 deletions(-)
sound/virtio/virtio_ctl_msg.c +16 -3
@@ -265,7 +265,7 @@ {struct virtio_device *vdev = snd->vdev;struct virtio_snd_queue *queue =virtsnd_control_queue (snd); -unsigned int js =msecs_to_jiffies (virtsnd_msg_timeout_ms); +unsigned long js =msecs_to_jiffies (virtsnd_msg_timeout_ms);struct virtio_snd_hdr *request =virtsnd_ctl_msg_request (msg);struct virtio_snd_hdr *response =virtsnd_ctl_msg_response (msg);unsigned int nouts =0 ;
@@ -273,7 +273,7 @@struct scatterlist *psgs[4 ];bool notify = false;unsigned long flags; -int rc; +long rc;virtsnd_ctl_msg_ref (msg);/* This reference stays with the queue until completion or teardown. */
@@ -314,7 +314,20 @@*/ virtsnd_ctl_msg_unref (msg); }else if (!nowait) { - rc =wait_for_completion_interruptible_timeout (&msg->notify, js); +/* +* Teardown must observe completion even with a pending signal. +* Otherwise a subsequent open can retry RELEASE while the device +* is still processing the previous teardown request. +*/ +switch (le32_to_cpu (request->code)) { +case VIRTIO_SND_R_PCM_STOP : +case VIRTIO_SND_R_PCM_RELEASE : + rc =wait_for_completion_timeout (&msg->notify, js); +break ; +default : + rc =wait_for_completion_interruptible_timeout (&msg->notify, js); +break ; + }if (!rc) { dev_err(&vdev->dev, "control message (0x%08x) timeout\n",
sound/virtio/virtio_ctl_msg.h +3 -0
@@ -47,6 +47,9 @@* The msg_timeout_ms module parameter defines the message completion timeout. * If the message is not completed within this time, the function will return an * error. +* PCM STOP and RELEASE wait through pending signals within this timeout. +* Other requests remain interruptible. Device reset cancels and wakes either +* kind of waiter. * * Context: Any context that permits to sleep. * Return: 0 on success, -errno on failure.
sound/virtio/virtio_pcm_ops.c +5 -5
@@ -20,11 +20,11 @@* (RELEASE command in the ops->sync_stop()) and the ops->hw_free() has been * called. * -* When the substream stops, the ops->sync_stop() waits until the device has -* completed all pending messages. This wait can be interrupted either by a -* signal or due to a timeout. In this case, the device can still access -* messages even after calling ops->hw_free(). It can also issue an interrupt, -* and the interrupt handler will also try to access message structures. +* When the substream stops, ops->sync_stop() stops and releases the device +* as required, then waits for pending messages. A failed control request or +* timed-out flush can leave the device able to access messages after +* ops->hw_free(). It can also issue an interrupt, and the interrupt handler +* will also try to access message structures. * The messages retain references to the PCM buffer pages until they are * freed, so late DMA does not target pages released by ALSA. *
PATCH v30 12/17 ALSA: virtio: use request-owned capture and serialize recovery
In reply to Joonho LeeReceive capture into request-owned buffers and commit completed requests in submission order. Append actual frame-aligned payloads contiguously to the ALSA ring, preserve a valid STOP tail, and retire empty requests without inventing data. Bound occupancy and report overflow through XRUN.
Add explicit, default-off compatibility options for packed status decoding and capture pause using RELEASE followed by PREPARE. The default capture path uses request-owned buffers.
Serialize control transitions and preparation by generation, keep payload and DMA ownership separate from the ALSA runtime, and stop admission after uncertain control completion. Preserve linked prepare and paused-error recovery semantics. Reject new ACK admissions after the core buffer-access gate closes, including linked members that have not entered their prepare callback. The PCM lock barriers wait for ACKs admitted before gate closure. Internal RESET pointer observation remains separately guarded.
Implement separate capture and playback RESET paths. A paused capture RESET keeps the modulo position of the last committed sample instead of rebasing the logical cursor independently of RX storage. This preserves the ordinary capture reset/reopen sample sequence.
Capture DRAINING uses the progress helper for every pending notification, including a tail crossing a period boundary and a latched error. Running capture and playback retain their period-timer behavior.
Retain request buffers until device ownership ends. This adds temporary memory and copies validated RX data while queue and stream locks are held. Each period buffer is allocated separately, so page rounding can make the allocation larger than the ALSA ring.
A separate narrow Linux 6.18.60 experiment provides evidence for the RX-credit root cause, not a qualification run of this full patch. With Scarlett 2i2 input 1 at actual 48 kHz, S16_LE mono, a 6,000-frame period and 24,000-frame buffer, the stock trace began with 48,000 bytes of request credit. Across 160 short completions it lost 36,192 bytes, leaving 11,808 bytes, 192 below the 12,000-byte next-request threshold, with no pending requests. ACK and period work still ran. Replay matched 452 state transitions and stored all 3,209 trace entries.
A separate opt-in Linux 6.18.60 candidate passed two 70-second captures and ten 3-second reopens using the same kernel binary as stock; only the virtio-snd module and options differed. This supports the narrow ordinary-load RX-credit repair only. It does not test this full patch. The narrow candidate omitted patches 1-5 policy/progress/reset/prepare/group-lock dependencies and patches 7-11 lifecycle/ownership coverage. Patch 13 work priority is not required for the observed normal-load dead end, but remains a separate performance change. Patches 15-16 cover playback separately.
RESET discards valid completed capture payloads already waiting for an earlier request at the pointer-observation boundary. Keep their sequence placeholders so later completions can advance without replaying the discarded samples. Preserve transport-owned requests and data completed after that boundary, and retain protocol-error reporting.
When a completion is rejected after an external XRUN or inactive runtime, release the other returned buffered entries as well. PREPARE continues to reset the complete generation after ownership is returned.
On failed native PAUSE, restore the previous capture-stopping flag and quiet sequence before reopening transfer admission. Otherwise old requests can retain the empty-tail exception while capture is running. The restore is guarded by the substream lock and reset epoch.
ARM64 QEMU controlled tests reproduce the v27 failures and pass the corrected ordering, RESET, XRUN and failed-PAUSE paths. The separately built production module passes RW/MMAP capture, RESET, playback pause and reopen regression tests with KASAN and lockdep.
---sound/virtio/virtio_card.c | 58 +
sound/virtio/virtio_ctl_msg.c | 58 + sound/virtio/virtio_ctl_msg.h | 9 sound/virtio/virtio_pcm.c | 103 ++ sound/virtio/virtio_pcm.h | 150 +++ sound/virtio/virtio_pcm_msg.c | 608 +++++++++++-- sound/virtio/virtio_pcm_ops.c | 1909 ++++++++++++++++++++++++++++++++++++----- 7 files changed, 2535 insertions(+), 360 deletions(-)
sound/virtio/virtio_card.c +52 -6
@@ -369,6 +369,23 @@struct virtio_device *vdev = snd->vdev;unsigned int i; +for (i =0 ; snd->substreams && i < snd->nsubstreams; ++i) { +struct virtio_pcm_substream *vss = &snd->substreams[i]; +struct virtio_snd_queue *queue =virtsnd_pcm_queue (vss); + +guard (spinlock_irqsave)(&queue->lock); +guard (spinlock)(&vss->lock); + vss->reset_epoch++; + vss->resetting = true; + vss->prepared = false; + vss->preparing = false; + vss->device_running = false; + vss->release_required = false; + vss->control_uncertain = false; + vss->capture_reset_observing = false; + vss->xfer_enabled = false; + vss->suspended = true; + }virtio_reset_device (vdev);/* Deleting a virtqueue does not unmap its outstanding descriptors. */
@@ -388,7 +405,6 @@ queue->vqueue =NULL ;spin_unlock_irqrestore (&queue->lock, flags); } -if (snd->vqs_initialized) { vdev->config->del_vqs (vdev); snd->vqs_initialized = false;
@@ -396,6 +412,30 @@ }/** +* virtsnd_cancel_period_work() - Drain PCM work after control cleanup. +* @snd: VirtIO sound device. +* +* Must follow control message cleanup, which wakes work blocked on a PCM +* control request. +* +* Context: Any context that permits to sleep. +*/ +static void virtsnd_cancel_period_work (struct virtio_snd *snd) +{ +unsigned int i; + +for (i =0 ; snd->substreams && i < snd->nsubstreams; ++i) { +struct virtio_pcm_substream *vss = &snd->substreams[i]; + +cancel_work_sync (&vss->elapsed_period); +guard (spinlock_irqsave)(&vss->lock); + vss->stopped = false; + vss->xfer_xrun = false; + vss->pause_restart_state =VIRTSND_PCM_PAUSE_RESTART_NONE ; + } +} + +/** * virtsnd_remove() - Remove VirtIO and ALSA devices. * @vdev: VirtIO parent device. *
@@ -414,12 +454,13 @@virtsnd_ctl_msg_cancel_all (snd);virtsnd_reset_vqs (snd); +/* Wake PCM workers blocked on control replies before draining them. */ virtsnd_ctl_msg_cleanup (snd); +virtsnd_cancel_period_work (snd);for (i =0 ; snd->substreams && i < snd->nsubstreams; ++i) {struct virtio_pcm_substream *vss = &snd->substreams[i]; -cancel_work_sync (&vss->elapsed_period);virtsnd_pcm_msg_free (vss); }
@@ -437,16 +478,14 @@static int virtsnd_freeze (struct virtio_device *vdev) {struct virtio_snd *snd = vdev->priv; -unsigned int i;virtsnd_disable_event_vq (snd);virtsnd_ctl_msg_cancel_all (snd);virtsnd_reset_vqs (snd); +/* Wake PCM workers blocked on control replies before draining them. */ virtsnd_ctl_msg_cleanup (snd); - -for (i =0 ; i < snd->nsubstreams; ++i) -cancel_work_sync (&snd->substreams[i].elapsed_period); +virtsnd_cancel_period_work (snd);kfree (snd->event_msgs); snd->event_msgs =NULL ;
@@ -465,6 +504,7 @@ {struct virtio_snd *snd = vdev->priv;int rc; +unsigned int i; rc =virtsnd_find_vqs (snd);if (rc) {
@@ -475,6 +515,12 @@virtio_device_ready (vdev);virtsnd_ctl_msg_enable (snd); +for (i =0 ; i < snd->nsubstreams; ++i) { +struct virtio_pcm_substream *vss = &snd->substreams[i]; + +guard (spinlock_irqsave)(&vss->lock); + vss->resetting = false; + }virtsnd_enable_event_vq (snd);return 0 ;
sound/virtio/virtio_ctl_msg.c +53 -5
86 lines not on this page · raw message
sound/virtio/virtio_ctl_msg.h +8 -1
@@ -11,6 +11,13 @@struct virtio_snd ;struct virtio_snd_msg ; +struct virtio_pcm_substream ; + +void virtsnd_ctl_msg_bind_pcm (struct virtio_snd_msg *msg, +struct virtio_pcm_substream *vss,u64 epoch); +u64 virtsnd_ctl_msg_pcm_epoch (struct virtio_snd_msg *msg); + +bool virtsnd_ctl_msg_uncertain (struct virtio_snd_msg *msg,int rc);void virtsnd_ctl_msg_ref (struct virtio_snd_msg *msg);
@@ -47,7 +54,7 @@* The msg_timeout_ms module parameter defines the message completion timeout. * If the message is not completed within this time, the function will return an * error. -* PCM STOP and RELEASE wait through pending signals within this timeout. +* PCM state-changing requests wait through pending signals within this timeout. * Other requests remain interruptible. Device reset cancels and wakes either * kind of waiter. *
sound/virtio/virtio_pcm.c +99 -4
130 lines not on this page · raw message
sound/virtio/virtio_pcm.h +144 -6
216 lines not on this page · raw message
sound/virtio/virtio_pcm_msg.c +514 -94
751 lines not on this page · raw message
sound/virtio/virtio_pcm_ops.c +1665 -244
1,685 lines not on this page · raw message
The rest of this diff is not shown. View the raw message.
Part of the diff is not shown here. View the raw message.
PATCH v30 13/17 ALSA: virtio: prioritize capture period work
In reply to Joonho LeeUse system_highpri_wq for capture progress notifications. Capture now always uses request-owned storage. Playback keeps the ordinary workqueue. This preserves the priority proposal separately from recovery and accounting. It provides no hard real-time guarantee and cannot prevent reader overruns.
---sound/virtio/virtio_pcm.h | 3 +++
1 file changed, 3 insertions(+)
sound/virtio/virtio_pcm.h +3 -0
@@ -173,6 +173,9 @@static inline bool virtsnd_pcm_schedule_period_elapsed (struct virtio_pcm_substream *vss) { +if (vss->direction ==SNDRV_PCM_STREAM_CAPTURE ) +return queue_work (system_highpri_wq, &vss->elapsed_period); +return schedule_work (&vss->elapsed_period); }
PATCH v30 14/17 docs: describe virtio-sound capture options
In reply to Joonho LeeDocument request-owned capture in the ALSA configuration guide. Describe capture_packed_status as default-off, reading a packed trailer after returned data while the fixed status scatterlist remains the default. Describe default-off capture_pause_restart: pause uses STOP and RELEASE, then resume uses PREPARE and START; disabled mode uses STOP and START while retaining the prepared stream.
Note that on MMU systems request buffers are vmalloc-backed and page-rounded individually. They remain allocated from hw_params through hw_free, and capture data is copied into the ALSA ring.
---Documentation/admin-guide/kernel-parameters.txt | 14 +++++++++++++
Documentation/sound/alsa-configuration.rst | 25 +++++++++++++++++++++++ 2 files changed, 39 insertions(+)
Documentation/admin-guide/kernel-parameters.txt +14 -0
@@ -8344,6 +8344,20 @@ Can be used multiple times for multiple devices. + virtio_snd.capture_packed_status= [HW,ALSA] + Read an explicitly enabled packed status trailer after + the returned capture data. The fixed status scatterlist is + used by default. + Format: <bool> + Default: false. + + virtio_snd.capture_pause_restart= [HW,ALSA] + Stop and release the stream when pausing capture. On + resume, send PREPARE and START. If disabled, pause uses + STOP and START while retaining the prepared stream. + Format: <bool> + Default: false. + vga= [BOOT,X86-32] Select a particular video mode See Documentation/arch/x86/boot.rst and Documentation/admin-guide/svga.rst.
Documentation/sound/alsa-configuration.rst +25 -0
@@ -2537,6 +2537,31 @@ This module supports multiple cards. +Module virtio-snd +----------------- + +Virtio-sound capture receives data into a separate request buffer for each +PCM period. The driver validates the responses and appends frame-aligned audio +to the ALSA ring in request order. Valid short responses are retained. Empty +responses are accepted only during bounded startup or for requests already in +flight at STOP or PAUSE. + +capture_packed_status + Read an explicitly enabled packed status trailer after returned capture + data. The fixed status scatterlist is used by default. + (default = false) + +capture_pause_restart + Stop and release capture on pause. Resume with PREPARE and START. When + disabled, pause uses STOP and START while retaining the prepared stream. + (default = false) + +On MMU systems, the request buffers are vmalloc-backed and page-rounded +individually. Allocator rounding can make total additional memory exceed the +ALSA ring size, especially with small periods. The request buffers remain +allocated from hw_params until hw_free. +Captured audio is copied from each request buffer into the ALSA ring. + Module snd-virtuoso -------------------
PATCH v30 15/17 ALSA: virtio: reject invalid playback completions
In reply to Joonho LeeA TX completion currently advances the hardware position even when the used length is malformed or the device reports an error. Validate the fixed status response before publishing progress. Retire the request once, latch XRUN and schedule error delivery while preparation is active. Keep malformed or failed transfers out of successful playback byte accounting.
---sound/virtio/virtio_pcm_msg.c | 11 +++++++++++
1 file changed, 11 insertions(+)
sound/virtio/virtio_pcm_msg.c +11 -0
@@ -1011,6 +1011,17 @@/* Playback requests point directly at the ALSA ring. */ guard (spinlock)(&vss->lock); +if (written_bytes !=sizeof (*msg->status) || +le32_to_cpu (msg->status->status) !=VIRTIO_SND_S_OK ) { + vss->xfer_xrun = true; + msg->length =0 ; + vss->msg_count--; +if (!vss->msg_count) +wake_up_all (&vss->msg_empty); +if (vss->prepared && !vss->preparing) +virtsnd_pcm_schedule_period_elapsed (vss); +return ; + } completed_bytes = msg->length; latency_bytes =le32_to_cpu (msg->status->latency_bytes); vss->hw_ptr += completed_bytes;
PATCH v30 16/17 ALSA: pcm: add an explicit application pointer to indirect playback transfer
In reply to Joonho LeeThe indirect playback transfer helper samples runtime->control->appl_ptr internally. A driver that needs to refill already committed data from a pointer callback cannot pass the application-pointer snapshot used for ACK validation.
Add snd_pcm_indirect_playback_transfer_appl_ptr() so callers can supply that snapshot. Keep snd_pcm_indirect_playback_transfer() as a wrapper that samples the runtime pointer as before, preserving existing callers.
The explicit-pointer form lets virtio refill accepted data without accepting new application progress while the ALSA buffer-access gate is closed.
---include/sound/pcm-indirect.h | 24 +++++++++++++++++++-----
1 file changed, 19 insertions(+), 5 deletions(-)
include/sound/pcm-indirect.h +19 -5
@@ -28,15 +28,17 @@ struct snd_pcm_indirect *rec, size_t bytes);/* -* helper function for playback ack callback +* Playback transfer using a caller-supplied application pointer snapshot. +* Passing rec->appl_ptr refills previously accepted data without accepting +* additional application progress. */ static inline int -snd_pcm_indirect_playback_transfer (struct snd_pcm_substream *substream, -struct snd_pcm_indirect *rec, -snd_pcm_indirect_copy_t copy) +snd_pcm_indirect_playback_transfer_appl_ptr (struct snd_pcm_substream *substream, +struct snd_pcm_indirect *rec, +snd_pcm_indirect_copy_t copy, +snd_pcm_uframes_t appl_ptr) {struct snd_pcm_runtime *runtime = substream->runtime; -snd_pcm_uframes_t appl_ptr = runtime->control->appl_ptr;snd_pcm_sframes_t diff = appl_ptr - rec->appl_ptr;int qsize;
@@ -72,6 +74,18 @@ rec->sw_ready -= bytes; }return 0 ; +} + +/* Preserve the application pointer sampling of the ordinary ACK helper. */ +static inline int +snd_pcm_indirect_playback_transfer (struct snd_pcm_substream *substream, +struct snd_pcm_indirect *rec, +snd_pcm_indirect_copy_t copy) +{ +snd_pcm_uframes_t appl_ptr = substream->runtime->control->appl_ptr; + +return snd_pcm_indirect_playback_transfer_appl_ptr (substream, rec, copy, + appl_ptr); }/*
PATCH v30 17/17 ALSA: virtio: preserve playback progress across pause and buffer access
In reply to Joonho LeeTX completions can arrive after PAUSE closes transfer admission. Preserve that progress and schedule catch-up when the stream resumes or a rejected pause restores RUNNING. Cache device latency in stream-owned state so a late completion does not need to dereference the ALSA runtime. Clear both the cache and runtime delay on prepare and before RESET observes the hardware pointer.
A playback pointer callback can also invoke ACK while the core has closed buffer-access admission, after the pointer helper has already accounted for completed hardware bytes. Track that callback context and refill only previously committed data using pcm_indirect.appl_ptr. Keep rejecting other ACKs while the gate is closed, and use the snd_pcm_indirect_playback_transfer_appl_ptr() for the refill. If runtime->control is absent, route the condition through the common playback validator and XRUN error path rather than returning before transfer failure handling.
Use the existing indirect hw_queue_size to keep outstanding TX below one physical ring: buffer_bytes - period_bytes. Equal modulo cursors then mean no unobserved completion, and a non-interrupt HWSYNC cannot consume a hidden full-ring wrap before deferred period work. Continue using the ordinary ALSA pointer update for silence, drain, stop-threshold and wakeup policy.
Check for pending progress or a latched transfer error again in the period worker under the PCM stream lock. A queued notification can outlive a paused RESET or an earlier pointer observation. Calling the period helper without new progress after resume can turn equal cursors into a false wrap when the core has backdated its pointer timestamp.
This reduces queued buffering by one period. With two periods, only one period can be queued.
The final candidate was tested on ARM64 QEMU with KASAN and lockdep. RW/MMAP boundary pause, release, HWSYNC/poll, drop and reopen passed with two- and eight-period rings. RW/MMAP also passed accepted RESET from PREPARED followed by DRAIN and reopen, and accepted RESET while RUNNING after the full 2,048-frame buffer became available.
A separate paired RW/MMAP gate fixture reproduced the baseline failure. The generic ALSA indirect helper invokes ACK for each pointer callback but masks its internal -EBADFD. Once hw_ptr == hw_io with no completion outstanding, virtio period-work progress suppresses further callbacks, so there is no ACK to retry the refill. Baseline stopped after 3,072 completed bytes with 1,024 bytes in sw_ready. The candidate drained sw_ready and completed 4,096 bytes without any further client ACK. A test-only hook changed appl_ptr to 2,560 while only 2,048 frames were committed; the candidate refilled only committed data. The hostile mutation used a test-only kernel hook because ARM64 control-page mmap is unsupported. KASAN and lockdep reported no diagnostics.
---sound/virtio/virtio_pcm.c | 3 ++
sound/virtio/virtio_pcm.h | 13 ++++++++ sound/virtio/virtio_pcm_msg.c | 8 ++--- sound/virtio/virtio_pcm_ops.c | 69 ++++++++++++++++++++++++++++++----------- 4 files changed, 70 insertions(+), 23 deletions(-)
sound/virtio/virtio_pcm.c +3 -0
@@ -338,6 +338,9 @@ }if (vss->direction !=SNDRV_PCM_STREAM_CAPTURE ) { +/* Ignore stale work after RESET rebases the playback cursors. */ +if (!virtsnd_pcm_playback_progress_pending (vss)) +return ;snd_pcm_period_elapsed_under_stream_lock (substream);return ; }
sound/virtio/virtio_pcm.h +13 -0
@@ -53,6 +53,7 @@* substream operators, including @stopped. * @buffer_bytes: Current buffer size in bytes. * @hw_ptr: Substream hardware pointer value in bytes [0 ... buffer_bytes). +* @playback_latency_bytes: Device delay cached independently of the ALSA runtime. * @capture_ready: Managed-mode bytes copied but not yet acknowledged by ALSA; * always zero in free-running mode. * @capture_boundary: ALSA boundary captured for this prepared epoch.
@@ -84,6 +85,8 @@* @capture_reset_observing: Reclaim staged samples during RESET pointer capture. * @indirect_reset_observing: Suppress ordinary ACK refill during RESET pointer * capture; protected by the PCM stream lock. +* @playback_pointer_active: Internal playback ACK context; protected by the +* PCM stream lock. * @suspended: True if the substream is suspended and must be reconfigured on * the device side at resume. * @pause_restart_state: Device-side state for opt-in pause compatibility.
@@ -113,6 +116,7 @@bool resetting;size_t buffer_bytes;size_t hw_ptr; +u32 playback_latency_bytes;size_t capture_ready;snd_pcm_uframes_t capture_boundary;u64 capture_copied_total;
@@ -140,6 +144,7 @@bool control_uncertain;bool capture_reset_observing;bool indirect_reset_observing; +bool playback_pointer_active;bool suspended;enum virtio_pcm_pause_restart_state pause_restart_state;struct virtio_pcm_msg **msgs;
@@ -179,6 +184,14 @@return schedule_work (&vss->elapsed_period); } +/* Caller holds the PCM stream lock so RESET cannot rebase these cursors. */ +static inline bool +virtsnd_pcm_playback_progress_pending (struct virtio_pcm_substream *vss) +{ +guard (spinlock_irqsave)(&vss->lock); +return vss->xfer_xrun || vss->hw_ptr != vss->pcm_indirect.hw_io; +} +/* * ALSA may observe a subperiod tail before its period callback. Keep actual * unread occupancy separate from pointer observations and notification state;
sound/virtio/virtio_pcm_msg.c +3 -5
@@ -1033,12 +1033,10 @@/* Keep latched errors until prepare establishes a fresh epoch. */ vss->msg_count--; -if (vss->xfer_enabled) { -struct snd_pcm_runtime *runtime = vss->substream->runtime; - - runtime->delay =bytes_to_frames (runtime, latency_bytes); +/* A queued request can outlive the ALSA runtime after hw_free. */ + vss->playback_latency_bytes = latency_bytes; +if (vss->prepared && !vss->preparing)virtsnd_pcm_schedule_period_elapsed (vss); - }if (!vss->msg_count)wake_up_all (&vss->msg_empty); }
sound/virtio/virtio_pcm_ops.c +51 -18
174 lines not on this page · raw message