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