sound: core: hwdep DSP_LOAD check-then-act is unlocked, allowing concurrent DSP_LOAD callbacks (UAF)
From: 徐晗翔
Date: Sun Nov 22 2026 - 02:53:01 EST
snd_hwdep_dsp_load() in sound/core/hwdep.c checks the
hw->dsp_loaded bit and then calls hw->ops.dsp_load() without holding a
lock. Two threads that share the same hwdep file descriptor (dup() or
fork()) can both pass the check and run the driver's dsp_load callback
concurrently; both then set the same bit. Upstream serializes the whole
check-and-load operation with a per-device dsp_mutex, which this tree
does not have at all: struct snd_hwdep has no dsp_mutex field,
snd_hwdep_new() does not initialize it, and snd_hwdep_dsp_load() has no
guard.
The driver callback is not required to be thread-safe. In-tree, the
usx2y driver's snd_usx2y_hwdep_dsp_load() calls usx2y_create_alsa_devices()
for index 1; that path registers ALSA devices and initializes URBs, and
usx2y_async_seq04_init()/usx2y_in04_init() use a non-atomic
WARN_ON(usx2y->as04.buffer) / WARN_ON(usx2y->in04_urb) check-then-act.
Concurrent DSP_LOAD can therefore duplicate device registration and
allocate/overwrite the same buffer/URB pointers, with double-free or
use-after-free consequences in the driver.
I reproduced the unlocked check on Linux 7.3 with a test hwdep device
whose dsp_load callback sleeps 300 ms and tracks concurrency. Four
threads sharing one fd issue SNDRV_HWDEP_IOCTL_DSP_LOAD; the log shows
active=1,2,3,4 in the callback (max_active=4). hw->exclusive only
guards open(), not concurrent ioctl() on an already-open fd. This run
did not produce a KASAN report because the callback is synthetic; the
proven claim is the broken mutual exclusion, with the usx2y consequence
argued from code.
The detailed description:
* Test environment / affected version
Linux version 7.3.0 (gcc 13.3.0, GNU ld 2.42) #6 SMP PREEMPT_DYNAMIC,
vanilla 7.3 source, KASAN, QEMU/KVM x86_64 (4 vCPU, 4 GB).
CONFIG_SND_HWDEP=y. Version line in evidence/kernel-version.txt.
* Root cause
sound/core/hwdep.c:206-222 (snd_hwdep_dsp_load):
if (hw->dsp_loaded & (1u << index))
return -EBUSY;
err = hw->ops.dsp_load(hw, &info);
if (err < 0)
return err;
hw->dsp_loaded |= (1u << index);
No lock covers the test, the callback and the bit update. Upstream
has guard(mutex)(&hw->dsp_mutex) around this sequence, and struct
snd_hwdep contains dsp_mutex; in this tree the field, the
mutex_init() in snd_hwdep_new() and the guard are all absent.
The ioctl path sound/core/hwdep.c:236-252 does not take open_mutex
around snd_hwdep_dsp_load(); open_mutex is held only by
snd_hwdep_open() for the exclusive/wait logic. hw->exclusive is a
one-time open() check, not a per-ioctl lock, and dup()/fork() share
the same struct file and hw->used without re-running open().
* Consequence in usx2y
sound/usb/usx2y/usX2Yhwdep.c:174-213
(snd_usx2y_hwdep_dsp_load) loads firmware images by index; for
index == 1 it calls usx2y_create_alsa_devices(hw->card), which
registers ALSA devices and starts the USB streams.
sound/usb/usx2y/usbusx2y.c:267-297 (usx2y_async_seq04_init) and
:299-334 (usx2y_in04_init) allocate buffers/URBs and use
WARN_ON(usx2y->as04.buffer) / WARN_ON(usx2y->in04_urb) as a
check-then-act guard; WARN_ON does not serialize. Two concurrent
index-1 loads can both allocate and overwrite these fields, and
usx2y_unlinkseq()/cleanup can then double-free or UAF them.
* Trigger model
- A hwdep device whose DSP load is performed by userspace (usx2y is
the in-tree example);
- a process opens /dev/snd/hwC*D* and dup()s the fd (or forks);
- two threads issue SNDRV_HWDEP_IOCTL_DSP_LOAD concurrently with the
same index;
- both pass the bit check and enter the driver callback.
No hardware is needed to demonstrate the unlocked check; the attached
test module does it.
* Reproducer (attached) and results on 7.3
sndcore_hwdep.c creates a card + hwdep device with hw->exclusive = 1
and a dsp_load callback that does:
atomic_inc(&active); update max_active; msleep(300); atomic_dec().
sndcore_test.c opens /dev/snd/hwC0D0 once and lets four pthreads issue
SNDRV_HWDEP_IOCTL_DSP_LOAD on that fd.
Observed :
dsp_load enter: index=0 active=1 entered=1 ...
dsp_load enter: index=0 active=2 entered=2 ...
dsp_load enter: index=0 active=3 entered=3 ...
dsp_load enter: index=0 active=4 entered=4 ...
HWDEP: 4 concurrent DSP_LOAD issued
KASAN bug count: 0
active=4 proves all four callbacks ran concurrently despite the
dsp_loaded check; the absence of KASAN is expected for a synthetic
callback and is stated as such.
* Suggested direction
Restore the upstream per-device dsp_mutex:
- add struct mutex dsp_mutex to struct snd_hwdep;
- mutex_init(&hwdep->dsp_mutex) in snd_hwdep_new();
- hold it across the dsp_loaded check, hw->ops.dsp_load() and the bit
update in snd_hwdep_dsp_load().
Please keep me in Cc; I am not subscribed to the lists.
Regards,
Hanxiang Xu
xuhx@xxxxxxxxxxx
// SPDX-License-Identifier: GPL-2.0
#define _GNU_SOURCE
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>
#include <unistd.h>
#include <errno.h>
#include <pthread.h>
#include <sys/ioctl.h>
#include <sound/asound.h>
static int write_free(const char *mod)
{
char path[256];
int fd;
snprintf(path, sizeof(path), "/sys/module/%s/parameters/free", mod);
fd = open(path, O_WRONLY);
if (fd < 0) {
fprintf(stderr, "open %s: %s\n", path, strerror(errno));
return -1;
}
if (write(fd, "1\n", 2) != 2)
fprintf(stderr, "write %s: %s\n", path, strerror(errno));
close(fd);
return 0;
}
static int do_hwdep(void)
{
struct snd_hwdep_dsp_image img;
int fd;
fd = open("/dev/snd/hwC0D0", O_RDWR);
if (fd < 0) {
fprintf(stderr, "open hwdep: %s\n", strerror(errno));
return 1;
}
memset(&img, 0, sizeof(img));
img.index = 0;
img.length = 0;
img.image = 0;
for (int i = 0; i < 4; i++) {
if (ioctl(fd, SNDRV_HWDEP_IOCTL_DSP_LOAD, &img) < 0)
fprintf(stderr, "ioctl dsp_load: %s\n", strerror(errno));
}
close(fd);
printf("HWDEP: ioctl done (max_active should be >= 2)\n");
sleep(1);
return 0;
}
static void *hwdep_thread(void *arg)
{
int fd = *(int *)arg;
struct snd_hwdep_dsp_image img;
memset(&img, 0, sizeof(img));
img.index = 0;
ioctl(fd, SNDRV_HWDEP_IOCTL_DSP_LOAD, &img);
return NULL;
}
static int do_hwdep_race(void)
{
pthread_t th[4];
int fd;
fd = open("/dev/snd/hwC0D0", O_RDWR);
if (fd < 0) {
fprintf(stderr, "open hwdep: %s\n", strerror(errno));
return 1;
}
for (int i = 0; i < 4; i++)
pthread_create(&th[i], NULL, hwdep_thread, &fd);
for (int i = 0; i < 4; i++)
pthread_join(th[i], NULL);
close(fd);
printf("HWDEP: 4 concurrent DSP_LOAD issued\n");
sleep(1);
return 0;
}
static int do_compress(void)
{
int fd;
fd = open("/dev/snd/comprC0D0", O_WRONLY);
if (fd < 0) {
fprintf(stderr, "open compress: %s\n", strerror(errno));
return 1;
}
printf("COMPRESS: fd open, freeing card\n");
write_free("sndcore_compress");
printf("COMPRESS: card free returned, issuing ioctl on stale fd\n");
if (ioctl(fd, 0x4300, 0) < 0)
fprintf(stderr, "ioctl stale fd: %s\n", strerror(errno));
printf("COMPRESS: ioctl returned without KASAN report\n");
close(fd);
sleep(1);
return 0;
}
static int do_rawmidi(void)
{
int fd;
fd = open("/dev/snd/midiC0D0", O_RDONLY);
if (fd < 0) {
fprintf(stderr, "open rawmidi: %s\n", strerror(errno));
return 1;
}
printf("RAWMIDI: fd open, letting flood thread run\n");
sleep(2);
printf("RAWMIDI: closing (trigger/cancel/free window)\n");
close(fd);
sleep(3);
printf("RAWMIDI: close returned, freeing card\n");
write_free("sndcore_rawmidi");
sleep(1);
return 0;
}
int main(int argc, char **argv)
{
if (argc < 2) {
fprintf(stderr, "usage: %s jackfree|compress|rawmidi|hwdep|hwdep-race\n", argv[0]);
return 2;
}
if (!strcmp(argv[1], "jackfree"))
return write_free("sndcore_jack");
if (!strcmp(argv[1], "compress"))
return do_compress();
if (!strcmp(argv[1], "rawmidi"))
return do_rawmidi();
if (!strcmp(argv[1], "hwdep"))
return do_hwdep();
if (!strcmp(argv[1], "hwdep-race"))
return do_hwdep_race();
fprintf(stderr, "unknown mode %s\n", argv[1]);
return 2;
}
Attachment:
sndcore_parent.h
Description: Binary data
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/slab.h>
#include <linux/delay.h>
#include <linux/atomic.h>
#include <sound/core.h>
#include <sound/hwdep.h>
#include "sndcore_parent.h"
static struct snd_card *card;
static struct snd_hwdep *hw;
static atomic_t active = ATOMIC_INIT(0);
static atomic_t entered = ATOMIC_INIT(0);
static int max_active;
static int free_set(const char *val, const struct kernel_param *kp)
{
if (card) {
snd_card_free(card);
card = NULL;
}
return 0;
}
static const struct kernel_param_ops free_ops = { .set = free_set };
module_param_cb(free, &free_ops, NULL, 0200);
module_param(max_active, int, 0444);
static void update_max(int v)
{
int old = READ_ONCE(max_active);
while (v > old && cmpxchg(&max_active, old, v) != old)
old = READ_ONCE(max_active);
}
static int test_dsp_load(struct snd_hwdep *h,
struct snd_hwdep_dsp_image *image)
{
int a = atomic_inc_return(&active);
int n = atomic_inc_return(&entered);
update_max(a);
pr_info("dsp_load enter: index=%u active=%d entered=%d image=%px len=%zu\n",
image->index, a, n, image->image, image->length);
msleep(300);
pr_info("dsp_load leave: index=%u active=%d\n", image->index, a);
atomic_dec(&active);
return 0;
}
static int __init sndcore_hwdep_init(void)
{
int err;
err = sndcore_card_new(&card, "sndcore_hwdep");
if (err < 0)
return err;
err = snd_hwdep_new(card, "sndcore", 0, &hw);
if (err < 0) {
snd_card_free(card);
card = NULL;
sndcore_parent_put();
return err;
}
hw->ops.dsp_load = test_dsp_load;
hw->exclusive = 1;
err = snd_card_register(card);
if (err < 0) {
snd_card_free(card);
card = NULL;
sndcore_parent_put();
return err;
}
pr_info("hwdep card registered\n");
return 0;
}
static void __exit sndcore_hwdep_exit(void)
{
if (card) {
snd_card_free(card);
card = NULL;
}
sndcore_parent_put();
}
module_init(sndcore_hwdep_init);
module_exit(sndcore_hwdep_exit);
MODULE_LICENSE("GPL");
MODULE_DESCRIPTION("sound/core MR-06 hwdep DSP_LOAD mutex verifier");