mirror of https://lore.kernel.org/lkml/
 help / color / mirror / Atom feed
From: 徐晗翔 <xuhx@hust.edu.cn>
To: perex@perex.cz, tiwai@suse.com
Cc: linux-sound@vger.kernel.org, linux-kernel@vger.kernel.org
Subject: sound: core: rawmidi input close can re-queue event_work after cancel_work_sync() (UAF)
Date: Sun, 22 Nov 2026 15:50:59 +0800 (GMT+08:00)	[thread overview]
Message-ID: <2033d529.2ad1b.1a2023ca712.Coremail.xuhx@hust.edu.cn> (raw)
In-Reply-To: <2026102727-data-sequel-ce41@gregkh>

[-- Attachment #1: Type: text/plain, Size: 6160 bytes --]

Closing a RawMIDI input stream can leave a work item queued after the
runtime object it uses has been freed.  close_substream() calls
snd_rawmidi_input_trigger(substream, 0) first; that function calls the
driver's trigger(0), then cancel_work_sync(&runtime->event_work) -- but
it does not hold substream->lock and it runs while substream->opened is
still 1.  Only afterwards does close_substream() take substream->lock,
set opened = 0, call ops->close() and snd_rawmidi_runtime_free(), which
kfree()s struct snd_rawmidi_runtime.

In the window between cancel_work_sync() returning and opened becoming 0
on another CPU, a driver can still call snd_rawmidi_receive().  receive()
takes substream->lock, sees opened == 1, queues data and executes
schedule_work(&runtime->event_work).  The work is then pending again, the
runtime is freed, and when the worker runs it dereferences
runtime->event and runtime->substream -- a use-after-free.  Upstream
closes this window with a second cancel_work_sync() after opened is
cleared (the comment says "Drain input work queued after the earlier
cancellation"), and also marks the substream disconnected in
snd_rawmidi_dev_disconnect().  Both protections are missing here.

I reproduced the UAF on Linux 7.3 with KASAN.  A test module registers a
rawmidi input stream and a kthread keeps calling snd_rawmidi_receive();
the user program opens /dev/snd/midiC0D0, closes it and frees the card.
The close path re-queues event_work after the first cancellation and the
work reports slab-use-after-free in snd_rawmidi_input_event_work()
(16 KASAN reports in the run).  To make the timing deterministic I added
verification-only mdelay() calls in the patched snd-rawmidi.ko: 100 ms
after cancel_work_sync() and 3000 ms at the start of the work.  They
widen the window but do not change the ordering; the patch is attached
so the claim can be audited and reverted.

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 with KASAN, QEMU/KVM x86_64 (4 vCPU, 4 GB).
  CONFIG_SND_RAWMIDI=m was enabled for the test; the only functional
  source change is the verification-only mdelay instrumentation in
  sound/core/rawmidi.c (patch attached).  Version line in
  evidence/kernel-version.txt.

* Root cause

  sound/core/rawmidi.c:216-224:

    static void snd_rawmidi_input_trigger(struct snd_rawmidi_substream *substream, int up)
    {
        if (!substream->opened)
            return;
        substream->ops->trigger(substream, up);
        if (!up)
            cancel_work_sync(&substream->runtime->event_work);
    }

  No substream->lock is held across the opened check, trigger and cancel.

  sound/core/rawmidi.c:533-565 (close_substream):

    if (cleanup) {
        if (substream->stream == SNDRV_RAWMIDI_STREAM_INPUT)
            snd_rawmidi_input_trigger(substream, 0);
        ...
    }
    scoped_guard(spinlock_irq, &substream->lock) {
        substream->opened = 0;
        substream->append = 0;
    }
    substream->ops->close(substream);
    ...
    snd_rawmidi_runtime_free(substream);   /* kfree(runtime) */

  sound/core/rawmidi.c:1146-1218 (snd_rawmidi_receive):

    guard(spinlock_irqsave)(&substream->lock);
    if (!substream->opened)
        return -EBADFD;
    ...
    if (result > 0) {
        if (runtime->event)
            schedule_work(&runtime->event_work);
        ...
    }

  Because receive() serializes with the opened=0 store but not with the
  earlier cancel_work_sync(), it can queue the work after cancel and
  before opened is cleared.  snd_rawmidi_runtime_free() does not cancel
  the work and does not re-check it.

  Upstream has an additional cancel_work_sync() after opened is cleared
  in close_substream(), plus a disconnected flag and cancel in
  snd_rawmidi_dev_disconnect(); this tree has neither.

* Trigger model

  - An input RawMIDI stream is open and has runtime->event set (the
    sequencer's snd_midi_input_event(), or a driver using the RawMIDI
    input API);
  - the stream is closed while the driver can still deliver input (for
    example a serial UART whose receive path checks its own
    "input open" mode bit until input_close(), or any driver that calls
    snd_rawmidi_receive() from its RX path);
  - receive() queues event_work after cancel_work_sync() and before
    opened=0; runtime is freed; the worker runs.

  The attached test module does not require special hardware: its kthread
  plays the role of a driver delivering input.

* Reproducer (attached) and results on 7.3

  sndcore_rawmidi.c creates a card + rawmidi input stream, installs a
  runtime->event callback and starts a kthread that loops:
  reset runtime->avail under substream->lock, then call
  snd_rawmidi_receive() with one byte.  sndcore_test.c opens
  /dev/snd/midiC0D0, sleeps, closes the fd, waits and frees the card.

  Observed :

    event callback entered n=3 opened=0
    BUG: KASAN: slab-use-after-free in snd_rawmidi_input_event_work+0x2d/0x60 [snd_rawmidi]
    Workqueue: events snd_rawmidi_input_event_work [snd_rawmidi]
    Call Trace:
     snd_rawmidi_input_event_work+0x2d/0x60 [snd_rawmidi]
     test_event+0x3f/0x60 [sndcore_rawmidi]
     process_one_work+...
    Allocated by task ...:
     open_substream+...
    Freed by task ...:
     close_substream.part.0+...
    Last potentially related work creation:
     snd_rawmidi_receive+0x31b/0x5a0 [snd_rawmidi]
     flood_fn+...
    KASAN bug count: 16

  The "opened=0" in the callback is the value observed after the UAF;
  the work ran after close, on the freed runtime.


* Suggested direction

  - In close_substream(), after opened is cleared, do a second
    cancel_work_sync(&runtime->event_work) for the input stream, as
    upstream does.
  - Restore the per-substream disconnected flag and the receive/trigger
    checks, and cancel the work in snd_rawmidi_dev_disconnect().
  - Consider taking substream->lock consistently around the opened
    check and cancellation, or document the lock ordering.

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

Regards,
Hanxiang Xu
xuhx@hust.edu.cn

[-- Attachment #2: sndcore_test.c --]
[-- Type: text/plain, Size: 3216 bytes --]

// 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 #3: sndcore_parent.h --]
[-- Type: application/octet-stream, Size: 746 bytes --]

/* SPDX-License-Identifier: GPL-2.0 */
#ifndef SNDCORE_PARENT_H
#define SNDCORE_PARENT_H

#include <linux/device.h>
#include <sound/core.h>

static struct device *sndcore_parent;

static inline int sndcore_card_new(struct snd_card **card, const char *name)
{
	int err;

	sndcore_parent = root_device_register(name);
	if (IS_ERR(sndcore_parent)) {
		err = PTR_ERR(sndcore_parent);
		sndcore_parent = NULL;
		return err;
	}
	err = snd_card_new(sndcore_parent, 0, "sndcore", THIS_MODULE, 0, card);
	if (err < 0) {
		root_device_unregister(sndcore_parent);
		sndcore_parent = NULL;
	}
	return err;
}

static inline void sndcore_parent_put(void)
{
	if (sndcore_parent) {
		root_device_unregister(sndcore_parent);
		sndcore_parent = NULL;
	}
}

#endif

[-- Attachment #4: sndcore_rawmidi.c --]
[-- Type: text/plain, Size: 3693 bytes --]

// SPDX-License-Identifier: GPL-2.0
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/slab.h>
#include <linux/kthread.h>
#include <linux/delay.h>
#include <linux/atomic.h>
#include <sound/core.h>
#include <sound/rawmidi.h>
#include "sndcore_parent.h"

static struct snd_card *card;
static struct snd_rawmidi *rmidi;
static struct task_struct *flood;
static struct snd_rawmidi_substream *in_sub;
static atomic_t events = ATOMIC_INIT(0);
static unsigned char byte = 0x5a;

static int rm_open(struct snd_rawmidi_substream *s) { return 0; }
static int rm_close(struct snd_rawmidi_substream *s) { return 0; }
static void rm_trigger(struct snd_rawmidi_substream *s, int up) { }
static void rm_drain(struct snd_rawmidi_substream *s) { }

static const struct snd_rawmidi_ops rm_ops = {
	.open = rm_open,
	.close = rm_close,
	.trigger = rm_trigger,
	.drain = rm_drain,
};

static void test_event(struct snd_rawmidi_substream *s)
{
	int n = atomic_inc_return(&events);
	if (n < 8)
		pr_info("event callback entered n=%d opened=%d\n", n, s->opened);
}

static int flood_fn(void *unused)
{
	int i;

	in_sub = list_first_entry(&rmidi->streams[SNDRV_RAWMIDI_STREAM_INPUT].substreams,
				  struct snd_rawmidi_substream, list);
	for (i = 0; i < 4000 && !kthread_should_stop(); i++) {
		if (READ_ONCE(in_sub->opened))
			break;
		msleep(5);
	}
	if (!READ_ONCE(in_sub->opened))
		return 0;
	if (in_sub->runtime)
		in_sub->runtime->event = test_event;
	pr_info("flood start: opened=%d runtime=%p\n", in_sub->opened, in_sub->runtime);

	while (!kthread_should_stop() && READ_ONCE(in_sub->opened)) {
		unsigned long flags;

		if (in_sub->runtime) {
			spin_lock_irqsave(&in_sub->lock, flags);
			if (in_sub->runtime)
				in_sub->runtime->avail = 0;
			spin_unlock_irqrestore(&in_sub->lock, flags);
		}
		snd_rawmidi_receive(in_sub, &byte, 1);
		cond_resched();
	}
	pr_info("flood stop: opened=%d events=%d\n", in_sub->opened, atomic_read(&events));
	return 0;
}

static int free_set(const char *val, const struct kernel_param *kp)
{
	if (card) {
		pr_info("free: calling snd_card_free(%p)\n", 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);

static int __init sndcore_rawmidi_init(void)
{
	int err;

	err = sndcore_card_new(&card, "sndcore_rawmidi");
	if (err < 0)
		return err;
	pr_info("card=%p module=%p this=%p\n", card, card->module, THIS_MODULE);
	if (card->module) {
		pr_info("try_module_get(card->module)=%d\n", try_module_get(card->module));
		module_put(card->module);
	}

	err = snd_rawmidi_new(card, "sndcore", 0, 0, 1, &rmidi);
	if (err < 0) {
		snd_card_free(card);
		card = NULL;
		sndcore_parent_put();
		return err;
	}
	rmidi->info_flags = SNDRV_RAWMIDI_INFO_INPUT;
	snd_rawmidi_set_ops(rmidi, SNDRV_RAWMIDI_STREAM_INPUT, &rm_ops);

	err = snd_card_register(card);
	if (err < 0) {
		snd_card_free(card);
		card = NULL;
		sndcore_parent_put();
		return err;
	}

	flood = kthread_run(flood_fn, NULL, "sndcore_flood");
	if (IS_ERR(flood)) {
		err = PTR_ERR(flood);
		flood = NULL;
		snd_card_free(card);
		card = NULL;
		sndcore_parent_put();
		return err;
	}
	pr_info("rawmidi card registered: dev=%s devt=%u:%u\n",
		dev_name(rmidi->dev), MAJOR(rmidi->dev->devt), MINOR(rmidi->dev->devt));

	return 0;
}

static void __exit sndcore_rawmidi_exit(void)
{
	if (flood) {
		kthread_stop(flood);
		flood = NULL;
	}
	if (card) {
		snd_card_free(card);
		card = NULL;
	}
	sndcore_parent_put();
}

module_init(sndcore_rawmidi_init);
module_exit(sndcore_rawmidi_exit);
MODULE_LICENSE("GPL");
MODULE_DESCRIPTION("sound/core MR-04 rawmidi event_work verifier");

  parent reply	other threads:[~2026-11-22  7:51 UTC|newest]

Thread overview: 71+ messages / expand[flat|nested]  mbox.gz  Atom feed  top
2026-10-27 12:35 usb: devio: usbdev_release() has no barrier against an in-flight async_completed() callback (use-after-free window on struct usb_dev_state)gregkh@linuxfoundation.org 徐晗翔
2026-10-27 14:12 ` Greg KH
2026-11-03 11:21   ` mm/slub: has_pcs_used() reads remote per-CPU sheaf state from flush_all_cpus_locked() without synchronization (data race; KCSAN blind spot: slub.o is uninstrumented) 徐晗翔
2026-11-04  9:41     ` Qing Wang
2026-11-04 10:07       ` Qing Wang
2026-11-03 11:30   ` futex/hrtimer: hrtimer_sleeper::task is read unsynchronized in 16 places on v7.3 -- the accessor series that fixes this is not in 7.3; please make sure it reaches the affected trees (backport nudge + stock-kernel KCSAN evidence) 徐晗翔
2026-11-03 11:48   ` cgroup: fork vs cgroup.procs write race in favordynmods mode -- v7.3 is affected; please make sure bf6fbf46b5ff reaches the stable trees (repro incl. uninstrumented natural hit) 徐晗翔
2026-11-03 14:51     ` Sasha Levin
2026-11-03 11:57   ` net: rtnetlink: rtnl_link_unregister() vs in-flight RTM_GETLINK dump readers -- v7.3 lacks the synchronize_rcu() fix (Fixes: 6b57ff21a310 family); A/B reproduction on stock 7.3 徐晗翔
2026-11-03 15:49     ` Eric Dumazet
2026-11-04 15:03     ` Sasha Levin
2026-11-03 12:07   ` wifi: wilc1000: SDIO/SPI remove destroys the srcu_struct before wiphy_unregister() -- late cfg80211 callbacks write through dangling srcu state (unfixed upstream; controlled + natural Oops) 徐晗翔
2026-11-03 12:10   ` gpio: gpiolib: final put of the gpio_device happens inside the SRCU read critical section on the setup-failure path -- deterministic use-after-free read at guard release (unfixed upstream) 徐晗翔
2026-11-05  8:52     ` Linus Walleij
2026-11-04 12:54   ` soc: qcom: pmic_glink_altmode: fix use-after-free on unbind (no cancel_work_sync for port work and enable_work) 徐晗翔
2026-11-04 13:04     ` Greg KH
2026-11-04 12:57   ` usb: typec: anx7411: unregister partner/altmodes before stopping the IRQ work -- use-after-free, double unregister, orphan partner on remove 徐晗翔
2026-11-04 13:28     ` Greg KH
2026-11-04 12:58   ` usb: typec: ucsi: deadlock on cros_ec unbind -- connector lock held across cancel_delayed_work_sync vs the mode-selection work's unbounded trylock polling 徐晗翔
2026-11-04 13:00   ` usb: typec: stusb160x/rt1719/hd3ss3220: IRQ thread vs remove -- double unregister / use-after-free on the partner and port 徐晗翔
2026-11-04 13:01   ` usb: typec: ucsi: displayport: data race on dp->header/ vdo_data/vdo_size -- work reads them unlocked while writers hold con->lock (VDM mismatch) 徐晗翔
2026-11-04 13:02   ` usb: typec: class: three lifetime/locking gaps around the mux/switch handles and mode_selection (drvdata UAF after provider unbind; no concurrent protocol for set/put; unlocked state_update vs delete) 徐晗翔
2026-11-10 12:56   ` driver core: uevent: netns teardown frees uevent_sock while a tagged uevent is still being broadcast (UAF) 徐晗翔
2026-11-10 13:00   ` 徐晗翔
2026-11-10 18:48     ` Greg KH
2026-11-10 13:05   ` ACPI: CPPC: per-CPU cpc_desc is freed on processor unbind without clearing the published pointer, causing UAF in cpufreq accessors 徐晗翔
2026-11-10 13:07   ` ACPI: CPPC: shared PCC subspace data can be freed while another CPU probes, reads, or tears it down 徐晗翔
2026-11-10 14:47     ` Christian Loehle
2026-11-10 13:11   ` ACPI: ACPICA: Reset can delete an event semaphore while another thread is blocked in Wait 徐晗翔
2026-11-10 13:14   ` power: supply: bq25890: pump-express work can call power_supply_changed after the psy is unregistered 徐晗翔
2026-11-10 13:17   ` power: supply: core: get/set property callbacks can run after unregister and read freed driver data 徐晗翔
2026-11-10 13:18   ` power: supply: core: system-battery enumeration can return an unregistered battery 徐晗翔
2026-11-10 13:21   ` power: supply: core: changed work can run after unregister and use freed LED triggers 徐晗翔
2026-11-10 13:23   ` power: supply: bq24190: IRQ handler can call power_supply_changed after the psy is unregistered 徐晗翔
2026-11-10 13:34   ` 徐晗翔
2026-11-11  7:17   ` genirq: NMI dispatch reads struct irqaction with no quiescence -- use-after-free across free_nmi()'s kfree (x86 verification on the arch-independent core path) 徐晗翔
2026-11-11  7:26   ` genirq: NMI API lacks the request_mutex / dev_id matching / idempotency semantics that free_irq() has -- double free_nmi releases chip PM and module references twice (verified) 徐晗翔
2026-11-11  7:30   ` kernfs: kernfs_drain()'s fast-path decision reads the active count without acquire ordering -- on weakly-ordered architectures the forced ->release()/unmap can be skipped 徐晗翔
2026-11-11 13:41     ` Greg KH
2026-11-13 11:58   ` ALSA: ctxfi: free atimer only after the timer IRQ is quiesced 徐晗翔
2026-11-13 16:30     ` Takashi Iwai
2026-11-13 12:03   ` ALSA: ctxfi: do not free a running system timer when timer_delete_sync_try() returns -1 (UAF) 徐晗翔
2026-11-13 12:04   ` ALSA: asihpi: free IRQ before snd_card_free()/HPI delete on HPI6205 removal (UAF) 徐晗翔
2026-11-13 12:06   ` ALSA: asihpi: quiesce PCM timer and IRQ before freeing dpcm on close (UAF) 徐晗翔
2026-11-13 12:15   ` ALSA: pcm: link-group walk in timer callback can use a closed substream's freed runtime (UAF) 徐晗翔
2026-11-13 12:28   ` ALSA: usb-audio: us144mkii: PCM close frees runtime while playback/feedback URB completion and capture work still use it (UAF) 徐晗翔
2026-11-13 12:29   ` ALSA: usb-audio: us144mkii: queued stop_pcm_work calls snd_pcm_stop() after PCM close and dereferences NULL runtime 徐晗翔
2026-11-13 12:33   ` sched/topology: old domain chains are queued for RCU freeing before the per-CPU pointers are updated, so a late reader can still dereference a freed sched_domain and sched_domain_shared (UAF) 徐晗翔
2026-11-13 12:47   ` xfs: use-after-free in stats_clear sysctl handler during module unload 徐晗翔
2026-11-13 12:48   ` xfs: data races on xfs_params and xfs_globals tunables 徐晗翔
2026-11-17 12:32   ` jbd2: fix unsynchronized read of j_average_commit_time in procfs stats (KCSAN data race) 徐晗翔
2026-11-17 12:33   ` jbd2: read j_stats.ts_tid under j_history_lock in fast commit path " 徐晗翔
2026-11-17 12:35   ` jbd2: fix unlocked read/write of j_last_sync_writer in jbd2_journal_stop " 徐晗翔
2026-11-17 12:38   ` btrfs: compression: data race on compr_pool.count between shrinker scan and folio alloc/free " 徐晗翔
2026-11-17 12:47   ` fs/ceph: debugfs mdsmap_show() can dereference a freed MDS map after a concurrent map update (UAF) 徐晗翔
2026-11-17 12:48   ` fs/ceph: ceph_statfs() can dereference a freed MDS map (double evaluation of mdsc->mdsmap) (UAF) 徐晗翔
2026-11-17 12:49   ` fs/ceph: ceph_get_tree() out_splat path walks mdsc->mdsmap without mdsc->mutex (UAF) 徐晗翔
2026-11-17 12:50   ` fs/ceph: __ceph_setxattr() reads mdsmap->m_max_xattr_size " 徐晗翔
2026-11-17 12:51   ` fs/ceph: MDS reconnect paths read mdsc->mdsmap " 徐晗翔
2026-11-17 12:52   ` fs/ceph: caps renew paths read mdsmap->m_session_timeout " 徐晗翔
2026-11-17 12:53   ` fs/ceph: MDS connections can deliver CEPH_MSG_MDS_MAP and re-enter ceph_mdsc_handle_mdsmap() (UAF) 徐晗翔
2026-11-22  7:37   ` mm/hugetlb: a min_size-only hugetlbfs subpool is kfree()d before its last pinned page is released, so free_huge_folio() takes a spinlock on freed memory (UAF) 徐晗翔
2026-11-22  7:39   ` io_uring/zcrx: copy statistics lose updates when one ifq is shared by multiple rings (Data race) 徐晗翔
2026-11-22  7:43   ` sound: core: compress offload fd does not pin card or module, so card removal leaves a live fd pointing at freed snd_compr (KASAN UAF) 徐晗翔
2026-11-22  8:07     ` Takashi Iwai
2026-11-22  7:48   ` sound: core: jack kcontrol is published before jack_kctl allocation, and the failure path frees it without removing it from card->controls (null-ptr-deref) 徐晗翔
2026-11-22  7:50   ` 徐晗翔 [this message]
2026-11-22  7:52   ` sound: core: hwdep DSP_LOAD check-then-act is unlocked, allowing concurrent DSP_LOAD callbacks (UAF) 徐晗翔
2026-11-22  7:55   ` sound: core: get_available_index() calls snd_ctl_find_id() without controls_rwsem (UAF risk) 徐晗翔
2026-11-22  7:56   ` sound: core: OSS mixer notify callback is invoked without module pin or mutex, racing with rmmod 徐晗翔
2026-11-22  7:57   ` sound: timer: snd_utimer_fops lacks .owner, so an open user timer fd does not pin snd-timer 徐晗翔

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=2033d529.2ad1b.1a2023ca712.Coremail.xuhx@hust.edu.cn \
    --to=xuhx@hust.edu.cn \
    --cc=linux-kernel@vger.kernel.org \
    --cc=linux-sound@vger.kernel.org \
    --cc=perex@perex.cz \
    --cc=tiwai@suse.com \
    /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 a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox

all inboxes | Powered by JetHome®