sound: core: OSS mixer notify callback is invoked without module pin or mutex, racing with rmmod

From: 徐晗翔

Date: Sun Nov 22 2026 - 02:56:44 EST


snd_mixer_oss_notify_callback is a bare exported function pointer. The
card core calls it from snd_card_register(), snd_card_disconnect() and
snd_card_do_free() without any mutex and without taking a reference to
the snd-mixer-oss module. alsa_mixer_oss_exit() sets the pointer to NULL
and then walks all cards calling SND_MIXER_OSS_NOTIFY_FREE, which frees
card->mixer_oss. A card thread can read the non-NULL pointer, be
preempted, let rmmod finish unloading the module, and then call the old
function pointer -- executing code from the unloaded module. The same
lack of serialization allows the module's exit FREE walk and the card's
do_free FREE callback to race and double-free card->mixer_oss.

Upstream avoids this with a static mixer_oss_notify_mutex plus
snd_mixer_oss_notify()/snd_mixer_oss_set_notify() wrappers; the exit path
clears the pointer under that mutex, so in-flight callbacks (including
their final module_put()) finish before unload. This tree exports the
raw pointer and calls it directly in three places.

This is a static report: the race is plain in the source, but I did not
build a dynamic reproducer for it. The requirement is
CONFIG_SND_MIXER_OSS=m so that an rmmod path exists.

The detailed description:

* Test environment / affected version

Source analysis against mainline 7.3; no dynamic reproducer was run
for this case.

* Root cause

sound/core/init.c:85-86:

int (*snd_mixer_oss_notify_callback)(struct snd_card *card, int free_flag);
EXPORT_SYMBOL(snd_mixer_oss_notify_callback);

direct calls:

- init.c:533-535 in snd_card_disconnect():
if (snd_mixer_oss_notify_callback)
snd_mixer_oss_notify_callback(card, SND_MIXER_OSS_NOTIFY_DISCONNECT);
- init.c:590-591 in snd_card_do_free():
if (snd_mixer_oss_notify_callback)
snd_mixer_oss_notify_callback(card, SND_MIXER_OSS_NOTIFY_FREE);
- init.c:935-936 in snd_card_register():
if (snd_mixer_oss_notify_callback)
snd_mixer_oss_notify_callback(card, SND_MIXER_OSS_NOTIFY_REGISTER);

module side:

- sound/core/oss/mixer_oss.c:1370:
snd_mixer_oss_notify_callback = snd_mixer_oss_notify_handler;
- mixer_oss.c:1386-1394 (alsa_mixer_oss_exit):
snd_mixer_oss_notify_callback = NULL;
for each card: snd_mixer_oss_notify_handler(card, SND_MIXER_OSS_NOTIFY_FREE);

The FREE handler (mixer_oss.c:1308-1360) takes card->mixer_oss, frees
it and sets card->mixer_oss = NULL. There is no lock around the
pointer read/call or around the mixer_oss pointer, and no module
reference is taken by the callback path. snd_mixer_oss_open()
(mixer_oss.c:57/73) takes try_module_get(card->module), not this
module; the OSS mixer file's .owner may pin the module only while such
an fd is open, so rmmod is possible with no OSS fd.

* Failure modes

1. Unloaded-code execution: card thread reads a non-NULL callback,
preempted; rmmod runs exit, sets NULL, unloads; card thread resumes
and calls into unmapped module text.
2. Double FREE: alsa_mixer_oss_exit() and snd_card_do_free() both
invoke the FREE callback for the same card. Both can read
card->mixer_oss before either sets it NULL and kfree() the same
object; or one frees while the other is inside the handler.
3. Card register/disconnect during rmmod can leave the pointer
cleared but a concurrent call already in flight with no completion
wait.

* Trigger model

- CONFIG_SND_MIXER_OSS=m (built-in has no unload path);
- one thread registers/disconnects/frees a card, another thread runs
rmmod snd-mixer-oss;
- the card thread must read the callback before the exit store and
reach the indirect call after unload, or both threads must reach the
FREE path concurrently.

Hotplug/unbind plus module unload is a realistic administration
sequence. It is a narrow but real race; the upstream mutex exists for
exactly this reason.

* Impact

- call into unloaded module text: UAF execution, kernel crash,
potential code execution if the address is reused;
- double free of card->mixer_oss: heap corruption;
- at minimum rmmod/hotplug crash.

* Suggested direction

Restore the upstream synchronization: a static mixer_oss_notify_mutex,
snd_mixer_oss_notify(card, cmd) that takes the mutex and checks the
pointer, and snd_mixer_oss_set_notify() used by the module init/exit to
install/clear the pointer under the same mutex. Ensure the exit path
waits for in-flight callbacks (including their module_put()) before
the module text is freed.


Please keep me in Cc; I am not subscribed to the lists.

Regards,
Hanxiang Xu
xuhx@xxxxxxxxxxx