jbd2: fix unlocked read/write of j_last_sync_writer in jbd2_journal_stop (KCSAN data race)

From: 徐晗翔

Date: Tue Nov 17 2026 - 07:35:30 EST


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@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;
}