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 unlocked read/write of j_last_sync_writer in jbd2_journal_stop (KCSAN data race)
Date: Tue, 17 Nov 2026 20:35:19 +0800 (GMT+08:00)	[thread overview]
Message-ID: <677b3182.28fca.1a1e9812c9b.Coremail.xuhx@hust.edu.cn> (raw)
In-Reply-To: <2026102727-data-sequel-ce41@gregkh>

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

jbd2_journal_stop() reads and writes journal->j_last_sync_writer before
taking read_lock(&journal->j_state_lock).  Two synchronous writers can
therefore both pass the "last writer is not me" test and both write the
pid, and the read in the batch-time heuristic is unsynchronized too.
KCSAN reports the 4-byte pid access; the same workload also reports a
1-byte access to the adjacent t_synchronous_commit bitfield.  The
observable effect is limited to batching/heuristic jitter; there is no
journal corruption or memory-safety impact.

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,max_batch_time=15000,min_batch_time=0.  Line
  numbers below are from 7.3.

* Mechanism

  jbd2_journal_stop() has the following sequence:

    fs/jbd2/transaction.c:1954-1963
      if (handle->h_sync && journal->j_last_sync_writer != pid &&
          journal->j_max_batch_time)
      {
          journal->j_last_sync_writer = pid;
          read_lock(&journal->j_state_lock);
          commit_time = journal->j_average_commit_time;
          read_unlock(&journal->j_state_lock);

  The condition load at transaction.c:1955 and the store at
  transaction.c:1959 both happen before the read_lock at
  transaction.c:1961.  The read lock protects only the adjacent
  j_average_commit_time load, not j_last_sync_writer.  The field is a
  plain pid_t:

    include/linux/jbd2.h:1166-1171
      /**
       * @j_last_sync_writer:
       *
       * The last writer which committed a sync transaction. This is used
       * to prevent multiple writers from sleeping for the same amount of
       * time.
       */
      pid_t j_last_sync_writer;

  Two h_sync handles on the same journal can execute this block
  concurrently.  Both can read the same old pid, both pass the
  comparison, and both store their own pid.  The last store wins; the
  earlier writer may still take the schedule_hrtimeout() path based on
  its stale view.  There is no locking, no READ_ONCE()/WRITE_ONCE(),
  and no atomic cmpxchg.

* Trigger model and reproducer

  The reproducer is jbd2_race.c.  Mode "mr03" starts 8 threads;
  each opens one file, sets the inode FS_SYNC_FL via FS_IOC_SETFLAGS,
  and loops pwrite(4096) followed by ftruncate(0).  IS_SYNC(inode)
  makes ext4_truncate() call ext4_handle_sync(), so the truncate path
  reaches jbd2_journal_stop() with h_sync set.  This is important:
  a plain fsync() goes through ext4_fc_commit()/full commit and did not
  reach the pid branch in our first attempts; O_SYNC writes also stayed
  on a different path.  The FS_SYNC_FL + ftruncate combination is the
  reliable userspace trigger.

  The mount must have a non-zero j_max_batch_time, otherwise the whole
  branch is skipped.  The harness mounts with
  max_batch_time=15000,min_batch_time=0.


* Observed result on 7.3

  The first 4-byte report is at 14.761 s:

    BUG: KCSAN: data-race in jbd2_journal_stop / jbd2_journal_stop

    write to 0xff468a70408d04a8 of 4 bytes by task 127 on cpu 1:
     jbd2_journal_stop+0x1f8/0x530
     __ext4_journal_stop+0x73/0x150
     ext4_truncate+0x3cc/0x620
     ext4_setattr+0x83f/0xc60
     notify_change+0x4f8/0x580
     do_ftruncate+0x229/0x2d0

    read to 0xff468a70408d04a8 of 4 bytes by task 128 on cpu 7:
     jbd2_journal_stop+0x1c4/0x530
     __ext4_journal_stop+0x73/0x150
     ext4_truncate+0x3cc/0x620
     ext4_setattr+0x83f/0xc60
     notify_change+0x4f8/0x580
     do_ftruncate+0x229/0x2d0

    value changed: 0x00000082 -> 0x0000007f

  The two values are PIDs.  Disassembly of the verification kernel shows
  the field at offset 0x4a8 of struct journal_s: +0x1c4 is the load
  used by the condition, +0x1f8 is the store.  j_max_batch_time is at
  offset 0x4bc and j_min_batch_time at 0x4b8, confirming the adjacent
  layout.  The control plan-mr03ctl.log has zero stop/stop reports and
  zero accesses at +0x1c4/+0x1f8.



* Suggested direction

  Make both the condition load and the store explicit, e.g.:

    pid_t last = READ_ONCE(journal->j_last_sync_writer);

    if (handle->h_sync && last != pid && journal->j_max_batch_time) {
        WRITE_ONCE(journal->j_last_sync_writer, pid);
        ...
    }

  This removes the KCSAN report and gives the compiler permission to
  treat the access as intentionally racy.  If the intent is to let only
  one writer win, use cmpxchg(&journal->j_last_sync_writer, last, pid)
  and only the winner sleeps; that is a behavior change and should be a
  separate patch.  Do not simply move the store under the existing
  read_lock: read_lock is a read-side lock, so two writers can still
  store concurrently under it.

  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:35 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   ` 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   ` 徐晗翔 [this message]
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=677b3182.28fca.1a1e9812c9b.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®