From mboxrd@z Thu Jan 1 00:00:00 1970 Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.remote-ip=74.125.82.46 ARC-Seal: i=1; d=subspace.kernel.org; s=arc20261015; a=rsa-sha256; cv=none; t=1794201407; b=UMuMpe3EzgzXbUcLKVRAcKbWZIAL4EWeyOnFiqNUGjYdClC12uct7upgBh76RRzHF5vs Zq6oaJ902sitX8daHmq7jMkEn3MZMqiIhZXf4vKkq824SCm3f4L83BJqcQpgVsgYes4Js bXTHbsAjpwCqUAxGXFQIwMqe5BncZdOxnKihwbDyuqwFZb40ykJqBapYvuatNaYKi5W/e Flr7RWQ0PqfDQXohjvAgbVBrqaY/KF12y5cM3VT5cc2cAasZUaXSVo+elgAX1rJrYCni3 3VrYWXUfuR6oJ6On1hfeWFHmCOJ6AxdEL286hwAwXDJmQwKANvfu8ffv+UT5XqUCK7g== ARC-Message-Signature: i=1; d=subspace.kernel.org; s=arc20261015; a=rsa-sha256; c=relaxed/relaxed; t=1794201407; h=DMARC-Filter:Received:DKIM-Signature:X-Google-DKIM-Signature: X-Forwarded-Encrypted:X-Gm-Message-State:X-Gm-Gg:X-Received:Received: From:To:Cc:Subject:Date:Message-ID:X-Mailer:In-Reply-To:References: MIME-Version:Content-Transfer-Encoding; bh=zJP1ksxof1hR+6LodwAgrvIXoMCXKKWVQGfaWA7IZwo=; b=2CR4OkfWFLLsV40r7Mnnxb0GU41TyX5UgWQCSNa3B6qwAoRFhLLvHxtP26T8RBRLDcHi JXB9baEEoFccabD4alxptdWRDLrk8D/gY3pnKDXaBJh8ioJx0k6nAqpaWGwmPFsq8CG05 nov9+wrJehCMI68iaw/1xiHid+Q7AIFtuMYYi322pVObiCbq3X67ufmWIFzsssyzRZNWF CSuSUOALM8wqwhepDcVxOanaAdf4By2iY3YFPcZnaF/1EoINLcc7WOwc8CwI/aadf69Ff xVNvvOtiBqbSRmMRt4vhEgVRQZMPBxaeQpNbAv2P9z2cc+NKmQpjdjaLBCCup+b4gTw== ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass header.from=gmail.com; spf=pass smtp.mailfrom=gmail.com; dkim=pass header.d=gmail.com header.i=@gmail.com header.a=rsa-sha256 header.s=20260707 header.b=E86uB43U; arc=none smtp.remote-ip=74.125.82.46 Received: from mail-dl1-f46.google.com (mail-dl1-f46.google.com [74.125.82.46]) (using TLSv1.3 with cipher TLS_AES_128_GCM_SHA256 (128/128 bits) key-exchange X25519 server-signature ECDSA (prime256v1) server-digest SHA256) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 483C4606D801 for ; Mon, 9 Nov 2026 05:16:47 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.4.2 smtp.subspace.kernel.org 483C4606D801 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=gmail.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.a=rsa-sha256 header.s=20260707 header.b=E86uB43U Received: by mail-dl1-f46.google.com with SMTP id a92af1059eb24-1a3c08d6928so843391c88.0 for ; Sun, 08 Nov 2026 21:16:47 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20260707; t=1794201406; x=1794806206; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to:content-type; bh=zJP1ksxof1hR+6LodwAgrvIXoMCXKKWVQGfaWA7IZwo=; b=E86uB43UfoHSC73Y/1yP9Zf54InwsRGF4JPKnbu9scQBu15j4rJD/2meoVW7Bu6Lhq 3kfawkbXcPNaIPd+ov9luIOrhi95j46kkcO+2vqIYAiFvmM1nAf3jUOR0J3sALHNbn1a EtDG74gkCXIwOKAN3ieFWHP3iIBUi/XuMzBZIJeaN2rvKgiCfMaTJuUa17L7rDGAEcEv E6+Mti5ic9TyGv/wPrOsrwdR1rWKCjjRaDza1AhTgUapLHuQz9CJnQEe8wuLVkjhubW3 lXmopjYMUhpuqdw8TgyA903Xj4U5RCoG4rTF/GAzBKqIDUlTbgD4b0KDeAgPafTL1Z0c uIBA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20260707; t=1794201406; x=1794806206; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-gg:x-gm-message-state:from :to:cc:subject:date:message-id:reply-to:content-type; bh=zJP1ksxof1hR+6LodwAgrvIXoMCXKKWVQGfaWA7IZwo=; b=wSuAOrFs47dmS/hYv9Zv+uRa9z5AxFz2LVXfbSkW1DAcxwulZylSwKA/w59ewWVnr3 w7j5TZoqREh8ktYHfB639al4ZGbBGlqNpuPLEhFwa1UdvRLdcKTulh4X4ftw1SWKv7N1 c3g0qCy9jsIAvwpQkGHdMi8qwOkyjS854DH0YWPcGYAXxtNgdPK9GVWBsBE3YsW2klOA yUNBZ29FOOfb6L4XGbwWPJeUSq6vA/8SBTUfe2b/vj6tBkw7LgNHJm3UZN9HhEqvfTcO RvFtAVOp1p4D7kPqxFw1IDUjTBwUy9VqeGL6TwBY7d3qfKMBoBUvB4vSPANiOGzMpPTC FN5Q== X-Forwarded-Encrypted: i=1; AL+hErERYQ3JLwob+AtRePEWrpE73OtSv4v6gX0d533veshHY+TxnkIsPfqBk6eJnW76K6outJouOUmryffvtdw=@vger.kernel.org X-Gm-Message-State: APuU4Z/h48SeYgJ26iWULmu5CbOyw9yr+wkMIVLOhmf1etziL43PmFXs xWA5piWakcLSv6gh/HGGWL5SKIQxBqoYZDF5xVzR8NEhc4FxJYAsNoCU X-Gm-Gg: AYBFou1iNDbm/KwruMh+dNBwHbsir3dRnvnkN3RyfXWlVIcZ0LgC9Jgrxid7CDOLdZh oCN0GpvBRzf9zCEE5hjYMxzGNzTOiFTvjTi7LyGUUf0wuzo33WYDIoX3hY/SoDXccugH3wvx4KT 1sJVPvvCdJQ2vSg5Hye9FkhqgY7M6TAg4YP1TEgPrGxySvXVmmeOoqWICkDjKs5151XYlcuUt1O cqdJQ2x/ZYLnwjFHYiKfRbye1kBz/nZgh4o98qDM5/aV/04K8eAStFAZh6e0G09KPs55FivYCQW Kjt8CwZ7ZELui76Q/sF/rlryg+gOKhvbodkFZP6cHwXyUAxxsH1ED8maBHevfGGtY23wIvXs/ZW EhtSKJolUS3gFNKBsTkgROOf2e67eBVlZ2uliLNSIozeRUKta2LUazsmAXrgAG2FRuAq8Nd7vrr 08GJl7BLagYNTwLIEysunPMx689+bNvu/jPpIUUvZPUJH6KeEcCZSq+Vzh72yLed8fFAOaKMB36 c2DvbfsiItWwNDarRZgj5zQ6khfTBxTZsjAN6WM9DPnUUx+1ehS+4488kywj0PSaJybsmDTwIfj qPCdIrpn/x6Vjq8bpQjZHXeICOn8FSJHBUAcGQe9ODQ6Lyaoq9csBrRQK4oSxQoP/XQQVDHC86b 4boYjEPcuJBiomjLlVhqfQcy1zXc4AvXtjXIclyJUEN1dYeZtX4eEKcfdSa1/okwtegV8 X-Received: by 2002:a05:7022:ec17:b0:144:c123:4036 with SMTP id a92af1059eb24-1b39fefeeedmr5909356c88.35.1794201406129; Sun, 08 Nov 2026 21:16:46 -0800 (PST) Received: from localhost.localdomain ([183.96.175.225]) by smtp.gmail.com with ESMTPSA id a92af1059eb24-1b37314826asm11395635c88.3.2026.11.08.21.16.43 (version=TLS1_3 cipher=TLS_CHACHA20_POLY1305_SHA256 bits=256/256); Sun, 08 Nov 2026 21:16:45 -0800 (PST) From: Joonho Lee To: linux-sound@vger.kernel.org Cc: tiwai@suse.com, perex@perex.cz, anton.yakovlev@opensynergy.com, mst@redhat.com, virtualization@lists.linux.dev, linux-kernel@vger.kernel.org, corbet@lwn.net, skhan@linuxfoundation.org, rdunlap@infradead.org, linux-doc@vger.kernel.org, Joonho Lee Subject: [PATCH v22 07/13] ALSA: virtio: Retain queued messages through device reset Date: Mon, 9 Nov 2026 14:16:12 +0900 Message-ID: <20261109051618.22506-8-mynameisjune111@gmail.com> X-Mailer: git-send-email 2.54.0 In-Reply-To: <20261109051618.22506-1-mynameisjune111@gmail.com> References: <20261108235457.12688-1-mynameisjune111@gmail.com> <20261109051618.22506-1-mynameisjune111@gmail.com> X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Post: List-Help: List-Subscribe: List-Unsubscribe: List-Owner: Precedence: list MIME-Version: 1.0 Content-Transfer-Encoding: 8bit Keep 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. Fixes: 9d45e514da88 ("ALSA: virtio: handling control messages") Assisted-by: LLM Signed-off-by: Joonho Lee --- 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(-) diff --git a/sound/virtio/virtio_card.c b/sound/virtio/virtio_card.c --- a/sound/virtio/virtio_card.c +++ b/sound/virtio/virtio_card.c @@ -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); diff --git a/sound/virtio/virtio_card.h b/sound/virtio/virtio_card.h --- a/sound/virtio/virtio_card.h +++ b/sound/virtio/virtio_card.h @@ -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; diff --git a/sound/virtio/virtio_ctl_msg.c b/sound/virtio/virtio_ctl_msg.c --- a/sound/virtio/virtio_ctl_msg.c +++ b/sound/virtio/virtio_ctl_msg.c @@ -15,6 +15,7 @@ * @list: Pending message list entry. * @notify: Request completed notification. * @ref_count: Reference count used to manage a message lifetime. + * @cancelled: Request canceled during device teardown. */ struct virtio_snd_msg { struct scatterlist sg_request; @@ -22,6 +23,7 @@ struct list_head list; struct completion notify; refcount_t ref_count; + bool cancelled; }; /** @@ -100,7 +102,7 @@ INIT_LIST_HEAD(&msg->list); init_completion(&msg->notify); - /* This reference is dropped in virtsnd_ctl_msg_complete(). */ + /* The caller owns this reference; send adds a queue reference. */ refcount_set(&msg->ref_count, 1); return msg; @@ -134,6 +136,7 @@ int rc; virtsnd_ctl_msg_ref(msg); + /* This reference stays with the queue until completion or teardown. */ /* Set the default status in case the message was canceled. */ response->code = cpu_to_le32(VIRTIO_SND_S_IO_ERR); @@ -147,12 +150,17 @@ psgs[nouts + nins++] = in_sgs; scoped_guard(spinlock_irqsave, &queue->lock) { - rc = virtqueue_add_sgs(queue->vqueue, psgs, nouts, nins, msg, - GFP_ATOMIC); + 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); } } @@ -168,9 +176,6 @@ goto on_exit; } - - if (notify) - virtqueue_notify(queue->vqueue); if (nowait) goto on_exit; @@ -184,6 +189,11 @@ rc = -ETIMEDOUT; } + goto on_exit; + } + + if (READ_ONCE(msg->cancelled)) { + rc = -ENODEV; goto on_exit; } @@ -227,9 +237,33 @@ * virtsnd_ctl_msg_cancel_all() - Cancel all pending control messages. * @snd: VirtIO sound device. * - * Context: Any context. + * Context: Any context. Blocks new senders and marks pending requests canceled. + * Existing senders are woken when their request completes or after + * the device has been reset. */ void virtsnd_ctl_msg_cancel_all(struct virtio_snd *snd) +{ + struct virtio_snd_queue *queue = virtsnd_control_queue(snd); + struct virtio_snd_msg *msg; + + guard(spinlock_irqsave)(&queue->lock); + snd->ctl_msgs_blocked = true; + list_for_each_entry(msg, &snd->ctl_msgs, list) { + WRITE_ONCE(msg->cancelled, true); + } +} + +/** + * virtsnd_ctl_msg_cleanup() - Release messages left after queue teardown. + * @snd: VirtIO sound device. + * + * This must be called after device reset, buffer detachment, and del_vqs(), + * when no queue callback or DMA access can still reach a message. The queue + * object and its lock must remain alive until this function returns. + * + * Context: Any context. + */ +void virtsnd_ctl_msg_cleanup(struct virtio_snd *snd) { struct virtio_snd_queue *queue = virtsnd_control_queue(snd); @@ -244,6 +278,20 @@ } /** + * virtsnd_ctl_msg_enable() - Allow control requests after queue restoration. + * @snd: VirtIO sound device. + * + * Context: Any context. + */ +void virtsnd_ctl_msg_enable(struct virtio_snd *snd) +{ + struct virtio_snd_queue *queue = virtsnd_control_queue(snd); + + guard(spinlock_irqsave)(&queue->lock); + snd->ctl_msgs_blocked = false; +} + +/** * virtsnd_ctl_query_info() - Query the item configuration from the device. * @snd: VirtIO sound device. * @command: Control request code (VIRTIO_SND_R_XXX_INFO). @@ -295,6 +343,8 @@ u32 length; guard(spinlock_irqsave)(&queue->lock); + if (queue->vqueue != vqueue) + return; do { virtqueue_disable_cb(vqueue); while ((msg = virtqueue_get_buf(vqueue, &length))) diff --git a/sound/virtio/virtio_ctl_msg.h b/sound/virtio/virtio_ctl_msg.h --- a/sound/virtio/virtio_ctl_msg.h +++ b/sound/virtio/virtio_ctl_msg.h @@ -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, diff --git a/sound/virtio/virtio_pcm.h b/sound/virtio/virtio_pcm.h --- a/sound/virtio/virtio_pcm.h +++ b/sound/virtio/virtio_pcm.h @@ -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); diff --git a/sound/virtio/virtio_pcm_msg.c b/sound/virtio/virtio_pcm_msg.c --- a/sound/virtio/virtio_pcm_msg.c +++ b/sound/virtio/virtio_pcm_msg.c @@ -305,6 +305,35 @@ { guard(spinlock_irqsave)(&vss->lock); return vss->msg_count; +} + +/** + * virtsnd_pcm_msg_cancel() - Cancel a message detached during device reset. + * @msg: Message returned by virtqueue_detach_unused_buf(). + * + * Reset cancellation retires the queue token without treating it as a device + * completion. In particular, it does not advance the PCM hardware pointer or + * schedule period work. + * + * Context: Process context with the PCM queue lock held. + */ +void virtsnd_pcm_msg_cancel(struct virtio_pcm_msg *msg) +{ + struct virtio_pcm_substream *vss = msg->substream; + bool wake; + + { + guard(spinlock)(&vss->lock); + msg->length = 0; + vss->xfer_enabled = false; + if (WARN_ON_ONCE(!vss->msg_count)) + return; + vss->msg_count--; + wake = !vss->msg_count; + } + + if (wake) + wake_up_all(&vss->msg_empty); } /** @@ -367,16 +396,21 @@ /** * virtsnd_pcm_notify_cb() - Process all completed I/O messages. - * @queue: Underlying tx/rx virtqueue. + * @queue: Underlying tx/rx queue wrapper. + * @vqueue: Queue that raised this callback. * * Context: Interrupt context. Takes and releases the tx/rx queue spinlock. */ -static inline void virtsnd_pcm_notify_cb(struct virtio_snd_queue *queue) +static inline void +virtsnd_pcm_notify_cb(struct virtio_snd_queue *queue, struct virtqueue *vqueue) { struct virtio_pcm_msg *msg; u32 written_bytes; guard(spinlock_irqsave)(&queue->lock); + /* Reset can detach the queue before the transport drains its IRQs. */ + if (queue->vqueue != vqueue) + return; do { virtqueue_disable_cb(queue->vqueue); while ((msg = virtqueue_get_buf(queue->vqueue, &written_bytes))) @@ -394,7 +428,7 @@ { struct virtio_snd *snd = vqueue->vdev->priv; - virtsnd_pcm_notify_cb(virtsnd_tx_queue(snd)); + virtsnd_pcm_notify_cb(virtsnd_tx_queue(snd), vqueue); } /** @@ -407,7 +441,7 @@ { struct virtio_snd *snd = vqueue->vdev->priv; - virtsnd_pcm_notify_cb(virtsnd_rx_queue(snd)); + virtsnd_pcm_notify_cb(virtsnd_rx_queue(snd), vqueue); } /**