mirror of https://lore.kernel.org/lkml/
 help / color / mirror / Atom feed
From: 徐晗翔 <xuhx@hust.edu.cn>
To: tytso@mit.edu, jack@suse.com
Cc: linux-ext4@vger.kernel.org, linux-kernel@vger.kernel.org
Subject: jbd2: fix unsynchronized read of j_average_commit_time in procfs stats (KCSAN data race)
Date: Tue, 17 Nov 2026 20:32:03 +0800 (GMT+08:00)	[thread overview]
Message-ID: <146ca01.28fb7.1a1e97e2dd7.Coremail.xuhx@hust.edu.cn> (raw)
In-Reply-To: <2026102727-data-sequel-ce41@gregkh>

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

jbd2_seq_info_show() reads journal->j_average_commit_time directly from
/proc/fs/jbd2/<device>/info, while the commit thread updates the same
u64 under write_lock(&journal->j_state_lock).  The field is documented
as protected by j_state_lock, and the existing reader in
jbd2_journal_stop() already takes read_lock() for it.  The procfs path
takes neither j_state_lock nor READ_ONCE()/data_race(), so KCSAN reports
a data race; on 32-bit builds the unlocked 64-bit read can also tear.

The detailed description:

* Test environment / affected version

  Linux version 7.3.0 (gcc 13.3.0, GNU ld 2.42) #1 SMP PREEMPT_DYNAMIC,
  vanilla mainline 7.3, rebuilt with CONFIG_KCSAN=y, CONFIG_EXT4_FS=y,
  CONFIG_JBD2=y, CONFIG_PROC_FS=y.  QEMU/KVM x86_64 guest, 8 vCPU,
  4 GB RAM.  The ext4 test image is 256 MB with an 8 MB journal and is
  mounted with commit=1.  Line numbers below are from 7.3.

* Mechanism

  Reader (procfs show path, process context):

    fs/jbd2/journal.c:1149-1150
      seq_printf(seq, "  %lluus average transaction commit time\n",
                 div_u64(s->journal->j_average_commit_time, 1000));

  This is a plain load of a u64 with no j_state_lock and no
  READ_ONCE()/data_race().  jbd2_seq_info_open() snapshots
  journal->j_stats under j_history_lock at journal.c:1186-1189, but the
  average commit time is deliberately read live from s->journal and is
  not part of that snapshot.

  Writer (kjournald2 commit thread):

    fs/jbd2/commit.c:1077       write_lock(&journal->j_state_lock);
    fs/jbd2/commit.c:1138-1142  if (likely(journal->j_average_commit_time))
                                    journal->j_average_commit_time =
                                        (commit_time +
                                         journal->j_average_commit_time * 3) / 4;
                                else
                                    journal->j_average_commit_time = commit_time;
    fs/jbd2/commit.c:1144       write_unlock(&journal->j_state_lock);

  The field annotation is explicit:

    include/linux/jbd2.h:1174-1179
      /**
       * @j_average_commit_time:
       *
       * The average amount of time in nanoseconds it takes to commit a
       * transaction to disk. [j_state_lock]
       */
      u64 j_average_commit_time;

  The same field is already read correctly elsewhere:

    fs/jbd2/transaction.c:1961-1963
      read_lock(&journal->j_state_lock);
      commit_time = journal->j_average_commit_time;
      read_unlock(&journal->j_state_lock);

  There is no common lock between the procfs show path and the commit
  thread.  seq_read_iter() holds m->lock, but the commit thread never
  takes it.

* Trigger model and reproducer

  The reproducer is jbd2_race.c, a userspace program run inside a
  minimal initramfs.  In mode "mr01" it starts 4 threads that repeatedly
  open and read /proc/fs/jbd2/vda-8/info, and 8 threads that write 4096
  bytes to /mnt/jbd2-<id> followed by fsync().  An 800 ms writer warmup
  ensures j_stats.ts_tid != 0, so the show path reaches the
  j_average_commit_time read.  Workload duration is 35 s.

* Observed result on 7.3

  The first report is at 10.651 s:

    BUG: KCSAN: data-race in jbd2_journal_commit_transaction / jbd2_seq_info_show

    read to 0xff2c44c8c0b02cb0 of 8 bytes by task 124 on cpu 1:
     jbd2_seq_info_show+0x29c/0x3b0
     seq_read_iter+0x237/0x6f0
     seq_read+0x1ad/0x1f0
     proc_reg_read+0xae/0x150

    read-write to 0xff2c44c8c0b02cb0 of 8 bytes by task 114 on cpu 2:
     jbd2_journal_commit_transaction+0x217f/0x2850
     kjournald2+0xfb/0x310

  The 8-byte width matches u64 j_average_commit_time.  The control run
  plan-mr01ctl.log produced 0 target reports (17 unrelated KCSAN reports
  from VFS/clocksource code were filtered out).


* Suggested direction

  Take a local snapshot under the existing read lock, then print it:

    u64 avg;

    read_lock(&journal->j_state_lock);
    avg = journal->j_average_commit_time;
    read_unlock(&journal->j_state_lock);
    seq_printf(seq, "  %lluus average transaction commit time\n",
               div_u64(avg, 1000));

  A READ_ONCE() would silence KCSAN but would not give the reader a
  consistent 64-bit value on 32-bit builds; the read lock is the
  stronger and already established protocol for this field.


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

Regards,
Hanxiang Xu
xuhx@hust.edu.cn

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

// SPDX-License-Identifier: GPL-2.0
/*
 * Userspace workload for JBD2 conditional-race verification.
 *
 * Modes:
 *   mr01      proc info reader + full-commit fsync writers
 *   mr01ctl   proc info reader only (no commit writer)
 *   mr03      concurrent h_sync fsync writers
 *   mr03ctl   single h_sync fsync writer
 *   mr02_once one mount's worth of fast-commit vs first full-commit attempts
 *
 * The ext4 image is mounted by init-jbd2 at /mnt.  The program never changes
 * kernel state; it only creates/writes/fsyncs files and reads
 * /proc/fs/jbd2/<dev>/info.
 */
#define _GNU_SOURCE
#include <errno.h>
#include <fcntl.h>
#include <glob.h>
#include <pthread.h>
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/ioctl.h>
#include <linux/fs.h>
#include <time.h>
#include <unistd.h>

static volatile sig_atomic_t stop_flag;
static char info_path[512];
static int nr_writers = 8;
static int nr_readers = 4;
static int writer_o_sync;
static int writer_truncate;

static void msleep(long ms)
{
	struct timespec ts;

	ts.tv_sec = ms / 1000;
	ts.tv_nsec = (ms % 1000) * 1000000L;
	while (nanosleep(&ts, &ts) < 0 && errno == EINTR)
		;
}

static int find_info_path(void)
{
	glob_t g;
	size_t i;
	int ret;

	ret = glob("/proc/fs/jbd2/*/info", 0, NULL, &g);
	if (ret != 0)
		return -1;
	for (i = 0; i < g.gl_pathc; i++) {
		if (access(g.gl_pathv[i], R_OK) == 0) {
			snprintf(info_path, sizeof(info_path), "%s",
				 g.gl_pathv[i]);
			globfree(&g);
			return 0;
		}
	}
	globfree(&g);
	return -1;
}

static void *reader_thread(void *arg)
{
	char buf[4096];
	unsigned long iter = 0;

	(void)arg;
	while (!stop_flag) {
		int fd = open(info_path, O_RDONLY);

		if (fd >= 0) {
			while (read(fd, buf, sizeof(buf)) > 0)
				;
			close(fd);
		}
		iter++;
	}
	fprintf(stderr, "JBD2RACE: reader done iter=%lu\n", iter);
	return NULL;
}

static void *writer_thread(void *arg)
{
	long id = (long)arg;
	char path[128];
	char buf[4096];
	unsigned long iter = 0;

	snprintf(path, sizeof(path), "/mnt/jbd2-%ld", id);
	memset(buf, 'A' + (id % 26), sizeof(buf));
	if (writer_truncate) {
		int fd = open(path, O_RDWR | O_CREAT, 0600);
		int fflags = 0;

		if (fd < 0) {
			fprintf(stderr, "JBD2RACE: open %s: %s\n", path, strerror(errno));
			return NULL;
		}
		if (ioctl(fd, FS_IOC_GETFLAGS, &fflags) == 0) {
			fflags |= FS_SYNC_FL;
			if (ioctl(fd, FS_IOC_SETFLAGS, &fflags) < 0)
				fprintf(stderr, "JBD2RACE: setflags %s: %s\n",
					path, strerror(errno));
		}
		while (!stop_flag) {
			if (pwrite(fd, buf, sizeof(buf), 0) < 0)
				fprintf(stderr, "JBD2RACE: pwrite %s: %s\n",
					path, strerror(errno));
			if (ftruncate(fd, 0) < 0)
				fprintf(stderr, "JBD2RACE: ftruncate %s: %s\n",
					path, strerror(errno));
			iter++;
		}
		close(fd);
		fprintf(stderr, "JBD2RACE: trunc writer %ld done iter=%lu\n",
			id, iter);
		return NULL;
	}
	while (!stop_flag) {
		int flags = O_RDWR | O_CREAT | O_TRUNC;
		int fd;

		if (writer_o_sync)
			flags |= O_SYNC;
		fd = open(path, flags, 0600);

		if (fd < 0) {
			if (errno != ENOSPC && errno != EROFS)
				fprintf(stderr, "JBD2RACE: open %s: %s\n",
					path, strerror(errno));
			msleep(1);
			continue;
		}
		if (writer_truncate) {
			int fflags = 0;

			if (ioctl(fd, FS_IOC_GETFLAGS, &fflags) == 0) {
				fflags |= FS_SYNC_FL;
				if (ioctl(fd, FS_IOC_SETFLAGS, &fflags) < 0)
					fprintf(stderr, "JBD2RACE: setflags %s: %s\n",
						path, strerror(errno));
			}
			if (pwrite(fd, buf, sizeof(buf), 0) < 0)
				fprintf(stderr, "JBD2RACE: pwrite %s: %s\n",
					path, strerror(errno));
			if (ftruncate(fd, 0) < 0)
				fprintf(stderr, "JBD2RACE: ftruncate %s: %s\n",
					path, strerror(errno));
			close(fd);
			iter++;
			continue;
		}
		if (write(fd, buf, sizeof(buf)) < 0 && errno != ENOSPC)
			fprintf(stderr, "JBD2RACE: write %s: %s\n",
				path, strerror(errno));
		if (fsync(fd) < 0 && errno != ENOSPC && errno != EROFS)
			fprintf(stderr, "JBD2RACE: fsync %s: %s\n",
				path, strerror(errno));
		close(fd);
		iter++;
	}
	fprintf(stderr, "JBD2RACE: writer %ld done iter=%lu\n", id, iter);
	return NULL;
}

static int run_threads(int readers, int writers, int secs, int warmup)
{
	pthread_t rth[16], wth[16];
	int i;

	if (readers > (int)(sizeof(rth) / sizeof(rth[0])))
		readers = sizeof(rth) / sizeof(rth[0]);
	if (writers > (int)(sizeof(wth) / sizeof(wth[0])))
		writers = sizeof(wth) / sizeof(wth[0]);
	if (find_info_path() < 0) {
		fprintf(stderr, "JBD2RACE: no /proc/fs/jbd2/*/info\n");
		return 1;
	}
	fprintf(stderr, "JBD2RACE: info=%s readers=%d writers=%d secs=%d\n",
		info_path, readers, writers, secs);

	stop_flag = 0;
	if (warmup) {
		pthread_t t;

		if (pthread_create(&t, NULL, writer_thread, (void *)0L) != 0)
			return 1;
		msleep(800);
		stop_flag = 1;
		pthread_join(t, NULL);
		stop_flag = 0;
	}
	for (i = 0; i < readers; i++) {
		if (pthread_create(&rth[i], NULL, reader_thread, NULL) != 0)
			return 1;
	}
	for (i = 0; i < writers; i++) {
		if (pthread_create(&wth[i], NULL, writer_thread,
				   (void *)(long)i) != 0)
			return 1;
	}
	msleep((long)secs * 1000);
	stop_flag = 1;
	for (i = 0; i < readers; i++)
		pthread_join(rth[i], NULL);
	for (i = 0; i < writers; i++)
		pthread_join(wth[i], NULL);
	fprintf(stderr, "JBD2RACE: run complete\n");
	return 0;
}

int main(int argc, char **argv)
{
	const char *mode;
	int secs = 30;
	int ret;

	if (argc < 2) {
		fprintf(stderr, "usage: %s <mr01|mr01ctl|mr03|mr03ctl|mr02_once> [secs]\n",
			argv[0]);
		return 2;
	}
	mode = argv[1];
	if (argc > 2)
		secs = atoi(argv[2]);
	if (secs <= 0)
		secs = 30;

	if (!strcmp(mode, "mr01")) {
		ret = run_threads(nr_readers, nr_writers, secs, 1);
	} else if (!strcmp(mode, "mr01ctl")) {
		ret = run_threads(nr_readers, 0, secs, 1);
	} else if (!strcmp(mode, "mr03")) {
		writer_truncate = 1;
		ret = run_threads(0, nr_writers, secs, 1);
	} else if (!strcmp(mode, "mr03ctl")) {
		writer_truncate = 1;
		ret = run_threads(0, 1, secs, 1);
	} else if (!strcmp(mode, "mr02_once")) {
		ret = run_threads(0, nr_writers, secs, 0);
	} else {
		fprintf(stderr, "JBD2RACE: unknown mode %s\n", mode);
		return 2;
	}
	return ret;
}

  parent reply	other threads:[~2026-11-17 12:32 UTC|newest]

Thread overview: 61+ 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   ` 徐晗翔 [this message]
2026-11-17 12:33   ` jbd2: read j_stats.ts_tid under j_history_lock in fast commit path (KCSAN data race) 徐晗翔
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) 徐晗翔

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=146ca01.28fb7.1a1e97e2dd7.Coremail.xuhx@hust.edu.cn \
    --to=xuhx@hust.edu.cn \
    --cc=jack@suse.com \
    --cc=linux-ext4@vger.kernel.org \
    --cc=linux-kernel@vger.kernel.org \
    --cc=tytso@mit.edu \
    /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®