jbd2: fix unsynchronized read of j_average_commit_time in procfs stats (KCSAN data race)
From: 徐晗翔
Date: Tue Nov 17 2026 - 07:32:17 EST
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@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;
}