jbd2: read j_stats.ts_tid under j_history_lock in fast commit path (KCSAN data race)
From: 徐晗翔
Date: Tue Nov 17 2026 - 07:34:14 EST
jbd2_fc_begin_commit() tests journal->j_stats.ts_tid before taking
j_state_lock, while jbd2_journal_commit_transaction() increments that
field under j_history_lock. The two accesses therefore have no common
lock and KCSAN reports a data race. In the observed window the reader
can see the initial zero after the first real commit has already
incremented ts_tid, causing jbd2_fc_begin_commit() to return -EINVAL and
ext4 to fall back to a full commit. This is a low-severity fast-commit
eligibility race, not a journal-format or data-integrity bug.
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 fast-commit image is 256 MB with an 8 MB journal and
the ext4 fast_commit feature enabled; it is mounted with commit=1.
Line numbers below are from 7.3.
* Mechanism
Reader (ext4 fsync -> fast commit begin):
fs/jbd2/journal.c:702-711
if (is_journal_aborted(journal))
return -EIO;
/* We are only called by the FS after it has called
* jbd2_journal_start() ... */
if (!journal->j_stats.ts_tid)
return -EINVAL;
write_lock(&journal->j_state_lock);
The ts_tid load at journal.c:708 is a plain read, before the write
lock is taken at journal.c:711.
Writer (kjournald2 commit thread, at the end of a full commit):
fs/jbd2/commit.c:1173-1185
spin_lock(&journal->j_history_lock);
journal->j_stats.ts_tid++;
...
spin_unlock(&journal->j_history_lock);
The declaration is:
include/linux/jbd2.h:738-742
struct transaction_stats_s {
unsigned long ts_tid;
unsigned long ts_requested;
...
};
and j_stats is embedded in struct journal_s at jbd2.h:1241-1243.
ts_tid is monotonic: it is zero until the first full commit, then
becomes non-zero forever. It does not wrap in any realistic journal
lifetime. The race is therefore a transition 0 -> non-zero that is
not published to the reader.
The reader's early check is not protected by j_history_lock, and the
writer does not take j_state_lock around the increment. There is no
common lock, and no READ_ONCE()/data_race() annotation.
* Trigger model and reproducer
The reproducer is jbd2_race.c, run inside a minimal initramfs.
The "mr02" plan performs up to 12 mount/unmount cycles on the
fast-commit image (11 completed in the recorded run). In each cycle it
starts 8 threads that write 4096 bytes to /mnt/jbd2-<id> and fsync(),
for 2 seconds, immediately after a fresh mount. A fresh journal gives the reader a chance to run before the
first full commit has published ts_tid; an 800 ms warmup is
deliberately not used in this mode.
* Observed result on 7.3
The first report is at 4.933 s:
BUG: KCSAN: data-race in jbd2_fc_begin_commit / jbd2_journal_commit_transaction
read-write to 0xff27e8144186c000 of 8 bytes by task 115 on cpu 7:
jbd2_journal_commit_transaction+0x220/0x2850
kjournald2+0xfb/0x310
read to 0xff27e8144186c000 of 8 bytes by task 127 on cpu 1:
jbd2_fc_begin_commit+0x27/0x160
ext4_fc_commit+0x200/0x2120
ext4_sync_file+0x1ef/0x4f0
__x64_sys_fsync+0xae/0xf0
do_syscall_64+0x114/0x380
The 8-byte width matches unsigned long ts_tid on this 64-bit build.
* Suggested direction
Snapshot ts_tid under j_history_lock before taking j_state_lock:
unsigned long ts_tid;
spin_lock(&journal->j_history_lock);
ts_tid = journal->j_stats.ts_tid;
spin_unlock(&journal->j_history_lock);
if (!ts_tid)
return -EINVAL;
Do not hold j_history_lock while taking j_state_lock: the commit
thread takes j_state_lock first and j_history_lock later, and nesting
them in the opposite order would create a lock-order inversion.
Alternatively, if maintainers consider the 0 -> non-zero transition
benign and intentionally racy, annotate the load with data_race() and
a comment; KCSAN would then stop reporting it. The lock snapshot is
the stronger option.
Please keep me in Cc; I am not subscribed to the lists.
Regards,
Hanxiang Xu
xuhx@xxxxxxxxxxx
// 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;
}