From: sashiko-bot@kernel.org
To: "Pavel Artemev" <a@pavel.bz>
Cc: linux-sound@vger.kernel.org
Subject: Re: [RFC PATCH v2 2/2] ALSA: usb-audio: add MIXER_STATE_REPUSH quirk flag
Date: Tue, 17 Nov 2026 08:18:53 +0000 [thread overview]
Message-ID: <sashiko-outbox-218409@kernel.org> (raw)
In-Reply-To: <20261117074318.378876-3-a@pavel.bz>
Thank you for your contribution! Sashiko AI review found 7 potential
issues to consider:
- [High] ALSA: usb-audio: runtime PM deadlock in snd_usb_mixer_suspend()
- [Medium] ALSA: usb-audio: stale master cache on suspend in
snd_usb_mixer_suspend()
- [Medium] ALSA: usb-audio: stale restore on autoresume in
snd_usb_mixer_flush_work()
- [Medium] ALSA: usb-audio: explicit master overwritten in
snd_usb_mixer_flush_pending()
- [Medium] ALSA: usb-audio: Mixer Unit misclassified in
is_feature_volume_mute_ctl()
- [Low] ALSA: usb-audio: read-only channel cache updated in
mixer_ctl_feature_put()
- [Low] ALSA: usb-audio: unratelimited usb_audio_info() on PCM open in
flush work
--
commit 57c12412dcfc2a07a4e6bcacef21bf4772a7601e
Author: Pavel Artemev <a@pavel.bz>
ALSA: usb-audio: add MIXER_STATE_REPUSH quirk flag
This commit adds the QUIRK_FLAG_MIXER_STATE_REPUSH quirk flag to defer
Feature Unit volume and mute writes into a coalesced burst and re-push the
cached mixer state when a PCM stream opens, enabling it for 040b:0897.
Link: https://bugzilla.kernel.org/show_bug.cgi?id=221401
Link: https://lore.kernel.org/linux-sound/20261116153521.188570-3-a@pavel.bz
> diff --git a/sound/usb/mixer.c b/sound/usb/mixer.c
> index bf1d9fbf08aae..cf3a211bfeb13 100644
> --- a/sound/usb/mixer.c
> +++ b/sound/usb/mixer.c
[ ... ]
> +static bool is_feature_volume_mute_ctl(struct usb_mixer_elem_info *cval)
> +{
> + if (!cval->head.kctl || !cval->head.kctl->put)
> + return false;
> + /* the info callback is shared with processing unit controls
> + * (whose put writes through a different path and does not manage
> + * the shared cache); the put callback is unique to feature unit
> + * and mixer unit controls, which the cache does cover
> + */
> + if (cval->head.kctl->put != mixer_ctl_feature_put)
> + return false;
> + return cval->control == UAC_FU_VOLUME || cval->control == UAC_FU_MUTE;
> +}
[Severity: Medium]
Can this misclassify Mixer Unit controls as Feature Unit mute or volume
controls?
Mixer Unit controls built by build_mixer_unit_ctl() also use
usb_feature_unit_ctl (.put = mixer_ctl_feature_put), but store the 1-based
input channel number (in_ch + 1) in cval->control:
sound/usb/mixer.c:build_mixer_unit_ctl() {
...
snd_usb_mixer_elem_init_std(&cval->head, state->mixer, unitid);
cval->control = in_ch + 1; /* based on 1 */
if (state->mixer->protocol == UAC_VERSION_2 ||
state->mixer->protocol == UAC_VERSION_3)
cval->v2_mixer = true;
cval->num_outputs = num_outs;
...
}
On a device with a Mixer Unit, input channel 1 (cval->control == 1 ==
UAC_FU_MUTE) is treated as a mute switch and skipped during stream-open
volume re-pushes, input channel 2 (cval->control == 2 == UAC_FU_VOLUME) is
treated as a Feature Unit volume control, and input channels 3 and higher
return false and bypass deferral and re-pushing altogether. Checking
!cval->num_outputs would exclude Mixer Unit controls.
[ ... ]
> +static void snd_usb_mixer_flush_pending(struct usb_mixer_interface *mixer,
> + bool full)
> +{
> + struct usb_mixer_elem_list *list;
> + struct usb_mixer_elem_info *cval, *master;
> + int id, c, idx, max_val;
> + bool have_ch, touched, master_pending;
> +
> + lockdep_assert_held(&mixer->lock);
> +
> + if (mixer->disconnected)
> + return;
> +
> + for (id = 0; id < MAX_ID_ELEMS; id++) {
> + master = NULL;
> + max_val = 0;
> + have_ch = false;
> + touched = false;
> + master_pending = false;
> + for_each_mixer_elem(list, mixer, id) {
> + cval = mixer_elem_list_to_info(list);
> + if (!is_feature_volume_mute_ctl(cval) ||
> + cval->control != UAC_FU_VOLUME)
> + continue;
> + if (!cval->cmask) {
> + if (!master) {
> + master = cval;
> + master_pending =
> + test_bit(0, cval->pending);
> + }
> + continue;
> + }
[ ... ]
> + /* master first (the Windows burst order) */
> + if (master && !master_pending && have_ch &&
> + (touched || full) &&
> + (!test_bit(0, master->cached) ||
> + *master->cache_val != max_val)) {
> + int err = snd_usb_set_cur_mix_value(master, 0, 0,
> + max_val);
> + if (err < 0)
> + usb_audio_dbg(mixer->chip,
> + "derive ctl %d ch 0 failed (%d)\n",
> + master->control, err);
> + }
[Severity: Medium]
Does this overwrite an explicit user-space master volume setting on the
next PCM stream open or per-channel write?
When user space sets the master control (cval->cmask == 0),
mixer_ctl_feature_put() sets bit 0 in master->pending. That keeps
master_pending true for the first flush, where flush_ctl_pending(master)
clears bit 0 of master->pending and writes *master->cache_val. On any
later stream open (full == true) or per-channel write (touched == true),
test_bit(0, master->pending) is now 0, so snd_usb_mixer_flush_pending()
sees !master_pending and overwrites both hardware channel 0 and
master->cache_val[0] with max_val.
[ ... ]
> +static void snd_usb_mixer_flush_work(struct work_struct *work)
> +{
> + struct usb_mixer_interface *mixer =
> + container_of(work, struct usb_mixer_interface,
> + flush_work.work);
> + bool full;
> +
> + scoped_guard(mutex, &mixer->lock) {
> + full = mixer->flush_full;
> + mixer->flush_full = false;
> + if (mixer->disconnected)
> + return;
> + if (full)
> + usb_audio_info(mixer->chip,
> + "flushing mixer state (stream open)\n");
[Severity: Low]
Should this use usb_audio_dbg() instead of usb_audio_info()? Audio
servers such as PipeWire open and close PCM substreams frequently, so
logging at info level on every stream open will spam dmesg.
> + snd_usb_mixer_flush_pending(mixer, full);
> + }
> +}
[Severity: Medium]
What happens when snd_usb_mixer_flush_work() runs while the device is
runtime-suspended?
mixer_ctl_feature_put() records deferred channel values in cval->cache_val
without waking the device, and snd_usb_mixer_flush_work() enters
snd_usb_mixer_flush_pending() without holding snd_usb_lock_shutdown(chip).
When snd_usb_mixer_flush_pending() calls snd_usb_set_cur_mix_value() for
the derived master volume, snd_usb_mixer_set_ctl_value() runs before
master->cache_val[0] is updated to max_val:
sound/usb/mixer.c:snd_usb_set_cur_mix_value() {
...
err = snd_usb_mixer_set_ctl_value(cval,
UAC_SET_CUR, (cval->control << 8) | channel,
value);
if (err < 0)
return err;
set_bit(channel, cval->cached);
cval->cache_val[index] = value;
return 0;
}
Inside snd_usb_mixer_set_ctl_value(), CLASS(snd_usb_lock, pm)(chip) calls
snd_usb_autoresume(chip), which synchronously runs usb_audio_resume() ->
snd_usb_mixer_resume() -> restore_mixer_value(). Because
master->cache_val[0] still holds its pre-flush value, restore_mixer_value()
writes the stale master value (and all other cached controls, including
mute switches and capture units) to the hardware before
snd_usb_mixer_flush_pending() writes the new master and pending channels a
second time. Acquiring CLASS(snd_usb_lock, pm)(mixer->chip) in
snd_usb_mixer_flush_work() and updating master->cache_val[0] before waking
the device would avoid the stale restore.
> +
> /* put the current value to feature/mixer unit */
> static int mixer_ctl_feature_put(struct snd_kcontrol *kcontrol,
> struct snd_ctl_elem_value *ucontrol)
> {
[ ... ]
> if (oval != val) {
> - err = snd_usb_set_cur_mix_value(cval, c + 1,
> - cnt, val);
> - if (err < 0)
> - return filter_error(cval, err);
> + if (deferred) {
> + /* record only; one flush writes the
> + * whole unit in a single burst
> + */
> + set_bit(c + 1, cval->cached);
> + cval->cache_val[cnt] = val;
> + set_bit(c + 1, cval->pending);
> + mod_delayed_work(system_wq,
> + &cval->head.mixer->flush_work,
> + MIXER_FLUSH_DELAY);
> + } else {
[Severity: Low]
Does the deferred path in mixer_ctl_feature_put() update cval->cache_val[]
for read-only channels?
In the direct path, snd_usb_set_cur_mix_value() checks
cval->master_readonly and cval->ch_readonly & BIT(channel - 1) and returns
before setting cval->cached or cval->cache_val[index]. Here, cval->cached
and cval->cache_val[] are updated before snd_usb_set_cur_mix_value() runs
in the flush worker, so a write to a read-only channel remains in the
cache and is returned by later gets and used when deriving max_val.
[ ... ]
> @@ -4007,6 +4320,7 @@ static int snd_usb_mixer_activate(struct usb_mixer_interface *mixer)
>
> int snd_usb_mixer_suspend(struct usb_mixer_interface *mixer)
> {
> + cancel_delayed_work_sync(&mixer->flush_work);
> snd_usb_mixer_inactivate(mixer);
> if (mixer->private_suspend)
> mixer->private_suspend(mixer);
[Severity: High]
Can cancel_delayed_work_sync(&mixer->flush_work) in
snd_usb_mixer_suspend() deadlock with snd_usb_mixer_flush_work()?
Neither mixer_ctl_feature_put() nor snd_usb_mixer_stream_opened() holds a
USB runtime PM reference across the 30 ms MIXER_FLUSH_DELAY window, and
usb_audio_suspend() does not increment chip->active. If the USB device
begins runtime suspend while mixer->flush_work is executing, the two
contexts deadlock:
kworker (PM) kworker (system_wq)
------------ -------------------
rpm_suspend(&udev->dev)
/* runtime_status = RPM_SUSPENDING */
...
usb_audio_suspend()
snd_usb_mixer_suspend()
snd_usb_mixer_flush_work()
snd_usb_mixer_flush_pending()
snd_usb_set_cur_mix_value()
snd_usb_mixer_set_ctl_value()
snd_usb_lock_shutdown()
snd_usb_autoresume()
usb_autopm_get_interface()
rpm_resume(&udev->dev)
/* waits on RPM_SUSPENDING */
cancel_delayed_work_sync(&mixer->flush_work)
*** DEADLOCK ***
Both workers sleep forever in TASK_UNINTERRUPTIBLE.
[Severity: Medium]
If snd_usb_mixer_suspend() cancels a pending mixer->flush_work before its
30 ms timer fires, does snd_usb_mixer_resume() restore a stale master
volume?
When mixer_ctl_feature_put() defers a per-channel volume write, it updates
the channel's cval->cache_val[cnt] and sets cval->pending, but the unit's
master control (master->cache_val[0]) is only updated to max_val when
snd_usb_mixer_flush_pending() runs. If suspend cancels mixer->flush_work
before it runs, snd_usb_mixer_resume() -> restore_mixer_value() writes the
stale pre-change master->cache_val[0] to channel 0 (which can leave the
device muted if master was previously at minimum) and leaves cval->pending
and mixer->flush_full set with no flush work scheduled. In addition,
because snd_usb_mixer_suspend() runs before snd_power_change_state() sets
SNDRV_CTL_POWER_D3hot in usb_audio_suspend() (and runtime suspend never
sets D3hot), a concurrent mixer_ctl_feature_put() can re-arm
mixer->flush_work after cancel_delayed_work_sync() returns.
--
Sashiko AI review · https://sashiko.dev/#/patchset/20261117074318.378876-1-a@pavel.bz?part=2
prev parent reply other threads:[~2026-11-17 8:18 UTC|newest]
Thread overview: 4+ messages / expand[flat|nested] mbox.gz Atom feed top
2026-11-17 7:43 [RFC PATCH v2 0/2] ALSA: usb-audio: working hardware volume for XiiSound headsets (040b:0897) Pavel Artemev
2026-11-17 7:43 ` [RFC PATCH v2 1/2] ALSA: usb-audio: drive XiiSound playback volume instead of skipping it Pavel Artemev
2026-11-17 7:43 ` [RFC PATCH v2 2/2] ALSA: usb-audio: add MIXER_STATE_REPUSH quirk flag Pavel Artemev
2026-11-17 8:18 ` sashiko-bot [this message]
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Save the following mbox file, import it into your mail client,
and reply-to-all from there: mbox
Avoid top-posting and favor interleaved quoting:
https://en.wikipedia.org/wiki/Posting_style#Interleaved_style
* Reply using the --to, --cc, and --in-reply-to
switches of git-send-email(1):
git send-email \
--in-reply-to=sashiko-outbox-218409@kernel.org \
--to=sashiko-bot@kernel.org \
--cc=a@pavel.bz \
--cc=linux-sound@vger.kernel.org \
--cc=sashiko-reviews@lists.linux.dev \
/path/to/YOUR_REPLY
https://kernel.org/pub/software/scm/git/docs/git-send-email.html
* If your mail client supports setting the In-Reply-To header
via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line
before the message body.
This is an external index of several public inboxes,
see mirroring instructions on how to clone and mirror
all data and code used by this external index.