From: Cyril Hrubis <chrubis@suse.cz>
To: Gaurav Pathak <gpathak@suse.de>
Cc: gaurav.pathak@suse.com, ltp@lists.linux.it
Subject: Re: [LTP] [PATCH v11] syscalls/statx13: Add test for STATX_WRITE_ATOMIC on regular file
Date: Fri, 20 Nov 2026 16:24:00 +0100 [thread overview]
Message-ID: <awBmECbdo7iUCXPv@yuki.lan> (raw)
In-Reply-To: <20261027-statx-atomic-write-v11-1-e9aeb50e56ce@suse.com>
Hi!
> +/*\
> + * Test :manpage:`statx(2)` support for the ``STATX_WRITE_ATOMIC`` mask on a
> + * regular file.
> + *
> + * STATX_WRITE_ATOMIC was added in Linux v6.11, initially for block
> + * devices. Regular-file reporting of atomic write limits on XFS and ext4
> + * was added later, in Linux v6.13, which is what this test exercises.
> + *
> + * There are two independent ways a filesystem can end up reporting atomic
> + * write support on a regular file, and this test exercises both:
> + *
> + * - Hardware-backed: the underlying block device itself advertises atomic
> + * write support (queried via statx(2) on the raw device before
> + * formatting). Both XFS and ext4 propagate the device's limits in this
> + * case. Loop devices never advertise this (the loop driver doesn't wire
> + * up atomic-write queue limits at all), so this path requires LTP_DEV to
> + * point at a real NVMe/SCSI device (or a scsi_debug-emulated one).
> + *
> + * - Software-backed (XFS only, Linux v6.16+): xfs_inode_can_sw_atomic_write()
> + * lets XFS complete an atomic write via CoW-based out-of-place writes
> + * instead of hardware support, gated purely by xfs_has_reflink() -- a
> + * filesystem feature, not a device capability. reflink is on by default
> + * for v5 (CRC-enabled) XFS filesystems, so a plain mkfs.xfs on top of a
> + * loop device will report working atomic write limits on a v6.16+
> + * kernel, with no special device needed. ext4 has no equivalent
> + * software fallback, so it always needs the hardware-backed path.
> + *
> + * When the test device does support hardware atomic writes, the
> + * filesystem block size is derived at runtime from the device's own
> + * atomic write unit limits, capped to 64KiB -- the hard block size
> + * ceiling enforced by both mkfs.xfs and mkfs.ext4 regardless of kernel
> + * capability -- and otherwise handled differently per filesystem:
> + *
> + * - XFS: without CONFIG_TRANSPARENT_HUGEPAGE, the block size is capped to
> + * the page size, since mkfs.xfs has no page-size pre-check and the
> + * kernel would otherwise reject a larger block size with ENOSYS at
> + * mount (mapping_max_folio_size_supported()). With THP available, the
> + * device's own atomic write max is used directly, except that a
> + * device reporting at least 64KiB is capped to exactly 16KiB rather
> + * than its full max, to exercise a non-default block size without
> + * nearing the 64KiB mkfs ceiling.
> + *
> + * - ext4: Since the kernel is able to mount only file systems with
> + * block-size smaller or equal to the system page size the block-size
> + * always stays at or below the page size and the cluster size never
> + * exceeds stx_atomic_write_unit_max and is strictly bounded by a max of
> + * 16 times the block size.
> + *
> + * When the test device does not support hardware atomic writes (e.g. the
> + * default loop-backed image LTP creates when LTP_DEV isn't set), ext4
> + * TCONFs immediately, while XFS is still formatted (with reflink forced
> + * on) and mounted, relying on verify_statx() to TCONF on its own if the
> + * running kernel predates the v6.16 software atomic write support.
> + *
> + * The test needs to run as root because it formats and mounts its own
> + * XFS and ext4 test filesystems.
> + */
> +
> +#define _GNU_SOURCE
> +#include <sys/mount.h>
> +#include "tst_test.h"
> +#include "lapi/stat.h"
> +
> +#define MNTPOINT "mnt_point"
> +#define TESTFILE MNTPOINT "/testfile"
> +#define MODE 0644
> +
> +/*
> + * Both xfsprogs (XFS_MAX_BLOCKSIZE) and e2fsprogs (EXT2_MAX_BLOCK_SIZE) cap
> + * the mkfs block size at 64KiB regardless of kernel/THP capability; mkfs
> + * rejects anything larger with "invalid block size" before the kernel is
> + * even involved.
> + */
> +#define MKFS_MAX_BLOCK_SIZE 65536
> +
> +static int file_fd = -1;
> +static int mount_flag;
> +static char *data_buff;
> +static struct ltp_statx *buff;
> +
> +static void verify_statx(void)
> +{
> + TST_EXP_PASS(statx(AT_FDCWD, TESTFILE, 0, STATX_BASIC_STATS | STATX_WRITE_ATOMIC, &buff->buff),
> + "statx(AT_FDCWD, %s, 0, STATX_BASIC_STATS | STATX_WRITE_ATOMIC, &buf)", TESTFILE);
> +
> + if (!TST_PASS)
> + return;
> +
> + /* Check if the kernel populated the atomic limit struct members */
> + if (!(buff->data.stx_mask & STATX_WRITE_ATOMIC))
> + tst_brk(TCONF, "Kernel may be too old to report atomic limits: STATX_WRITE_ATOMIC missing from stx_mask");
First of all can we keep the messages shorter an to the point? The
second part of the message "STATX_WRITE_ATOMIC missing from stx_mask"
does not add any useful information, only adds to the message lenght.
And it's the same for the rest of the messages produced by the test.
> + /* Check if the filesystem supports reporting the atomic write attribute */
> + if (!(buff->data.stx_attributes_mask & STATX_ATTR_WRITE_ATOMIC)) {
> + tst_res(TFAIL, "Inconsistent: stx_mask has STATX_WRITE_ATOMIC but stx_attributes_mask lacks STATX_ATTR_WRITE_ATOMIC");
> + return;
> + }
> +
> + /* Check if the file/device actively supports atomic writes */
> + if (!(buff->data.stx_attributes & STATX_ATTR_WRITE_ATOMIC)) {
> + if (buff->data.stx_atomic_write_unit_min || buff->data.stx_atomic_write_unit_max ||
> + buff->data.stx_atomic_write_unit_max_opt || buff->data.stx_atomic_write_segments_max) {
> + tst_res(TFAIL,
> + "Inconsistent: STATX_ATTR_WRITE_ATOMIC unset but limits nonzero (min=%u max=%u opt=%u segs=%u)",
> + buff->data.stx_atomic_write_unit_min, buff->data.stx_atomic_write_unit_max,
> + buff->data.stx_atomic_write_unit_max_opt, buff->data.stx_atomic_write_segments_max);
> + return;
> + }
> +
> + tst_brk(TCONF, "STATX_WRITE_ATOMIC unsupported by block dev or filesystem: STATX_ATTR_WRITE_ATOMIC missing from stx_attributes");
> + }
> +
> + TST_EXP_EXPR(buff->data.stx_atomic_write_unit_min <= buff->data.stx_atomic_write_unit_max,
> + "stx_atomic_write_unit_min(%u) <= stx_atomic_write_unit_max(%u)",
> + buff->data.stx_atomic_write_unit_min, buff->data.stx_atomic_write_unit_max);
We have macros for comparsions TST_EXP_LE_*.
> + TST_EXP_EXPR(buff->data.stx_atomic_write_segments_max > 0,
> + "stx_atomic_write_segments_max(%u) > 0", buff->data.stx_atomic_write_segments_max);
> +
> + TST_EXP_EXPR(buff->data.stx_atomic_write_unit_min > 0 &&
> + !(buff->data.stx_atomic_write_unit_min & (buff->data.stx_atomic_write_unit_min - 1)),
This is really ugly, I guess that we should add TST_EXP_POW2() that
would check that the number is a power of two.
> + "stx_atomic_write_unit_min(%u) is a power of 2",
> + buff->data.stx_atomic_write_unit_min);
> +
> + TST_EXP_EXPR(buff->data.stx_atomic_write_unit_max > 0 &&
> + !(buff->data.stx_atomic_write_unit_max & (buff->data.stx_atomic_write_unit_max - 1)),
> + "stx_atomic_write_unit_max(%u) is a power of 2",
> + buff->data.stx_atomic_write_unit_max);
> +
> + if (buff->data.stx_atomic_write_unit_max_opt == 0) {
> + tst_res(TPASS, "stx_atomic_write_unit_max_opt is 0 (no optimized max reported)");
> + } else {
> + if (buff->data.stx_atomic_write_unit_max_opt > buff->data.stx_atomic_write_unit_max) {
> + tst_res(TFAIL, "stx_atomic_write_unit_max_opt (%u) exceeds max (%u)",
> + buff->data.stx_atomic_write_unit_max_opt,
> + buff->data.stx_atomic_write_unit_max);
> + } else if (buff->data.stx_atomic_write_unit_max_opt < buff->data.stx_atomic_write_unit_min) {
> + tst_res(TFAIL, "stx_atomic_write_unit_max_opt (%u) is less than min (%u)",
> + buff->data.stx_atomic_write_unit_max_opt,
> + buff->data.stx_atomic_write_unit_min);
> + } else {
> + tst_res(TPASS, "stx_atomic_write_unit_max_opt (%u) is within valid range [%u, %u]",
> + buff->data.stx_atomic_write_unit_max_opt,
> + buff->data.stx_atomic_write_unit_min,
> + buff->data.stx_atomic_write_unit_max);
> + }
This is very ugly as well. If we need strict less than we should add
TST_EXP_LT_* macros and make use of these here.
> + TST_EXP_EXPR(!(buff->data.stx_atomic_write_unit_max_opt & (buff->data.stx_atomic_write_unit_max_opt - 1)),
> + "stx_atomic_write_unit_max_opt(%u) is a power of 2",
> + buff->data.stx_atomic_write_unit_max_opt);
> + }
> +}
> +
> +static int has_thp(void)
> +{
> + return access(PATH_MM_THP, F_OK) == 0;
> +}
> +
> +static void setup(void)
> +{
> + struct ltp_statx dev_stx;
> + struct stat sb;
> + char opt_bsize[32];
> + char opt_cluster[32];
> + const char *fs_opts[8];
> + unsigned int min, max, bsize = 0;
> + int dev_has_atomic;
> +
> + SAFE_STATX(AT_FDCWD, tst_device->dev, 0, STATX_WRITE_ATOMIC, &dev_stx);
> +
> + /*
> + * stx_mask only gains STATX_WRITE_ATOMIC when bdev_can_atomic_write()
> + * is true (see block/bdev.c:bdev_statx()), i.e. this is a device
> + * capability signal, not a kernel version one: .min_kver = "6.13"
> + * above already guarantees the kernel is new enough for the field to
> + * exist at all. So any of these three being unset simply means this
> + * particular device (most commonly a loop device) has no atomic
> + * write support to report.
> + */
> + dev_has_atomic = (dev_stx.data.stx_mask & STATX_WRITE_ATOMIC) &&
> + (dev_stx.data.stx_attributes_mask & STATX_ATTR_WRITE_ATOMIC) &&
> + (dev_stx.data.stx_attributes & STATX_ATTR_WRITE_ATOMIC);
> +
> + if (!dev_has_atomic && strcmp(tst_device->fs_type, "xfs")) {
> + /*
> + * Unlike XFS, ext4 has no device-independent (software)
> + * atomic write mechanism: ext4_atomic_write_init() always
> + * requires bdev_can_atomic_write() to be true. So without
> + * device support there is nothing for ext4 to exercise here.
> + */
> + tst_brk(TCONF,
> + "%s does not support atomic writes (loop devices never do) and ext4 has no software atomic write fallback; set LTP_DEV to a real NVMe/SCSI device, or load scsi_debug",
> + tst_device->dev);
> +
> + }
> +
> + if (!dev_has_atomic) {
> + /*
> + * No hardware atomic write support, but XFS can still
> + * complete atomic writes via CoW-based out-of-place writes
> + * (xfs_inode_can_sw_atomic_write()) as long as reflink is
> + * enabled, independently of the backing device -- this
> + * works even on a plain loop device, but only since Linux
> + * v6.16. Force reflink on explicitly rather than relying on
> + * mkfs.xfs defaults, and skip the device-limit-based block
> + * size selection below entirely since it doesn't apply here.
> + * If the running kernel predates v6.16, verify_statx() will
> + * TCONF on its own once it sees STATX_WRITE_ATOMIC missing.
> + */
These long comments only copy information from the top level doc
comment. Since we already have them there we shouldn't add them here for
a second time.
> + tst_res(TINFO,
> + "%s has no atomic write support; relying on XFS's software (CoW-based, reflink) atomic writes instead (requires Linux v6.16+)",
> + tst_device->dev);
> +
> + fs_opts[0] = "-f";
> + fs_opts[1] = "-m";
> + fs_opts[2] = "reflink=1";
> + fs_opts[3] = NULL;
> +
> + SAFE_MKFS(tst_device->dev, tst_device->fs_type, fs_opts, NULL);
> + goto mount_fs;
> + }
> +
> + min = dev_stx.data.stx_atomic_write_unit_min;
> + max = dev_stx.data.stx_atomic_write_unit_max;
> +
> + if (!min || !max)
> + tst_brk(TCONF, "%s reports zero atomic write unit limits", tst_device->dev);
> +
> + if (!strcmp(tst_device->fs_type, "xfs")) {
> + if (max >= 65536 && has_thp())
> + bsize = 16384;
> + else if (has_thp())
> + bsize = max;
> + else
> + bsize = MIN(max, (unsigned int)getpagesize());
> + } else {
> + bsize = MIN(max, (unsigned int)getpagesize());
> + }
> +
> + bsize = MIN(bsize, (unsigned int)MKFS_MAX_BLOCK_SIZE);
> +
> + if (bsize < min) {
> + tst_brk(TCONF,
> + "Device's minimum atomic write unit (%u) exceeds the largest block size this test can configure (%u)",
> + min, bsize);
> + }
> +
> + if (!strcmp(tst_device->fs_type, "xfs")) {
> + tst_res(TINFO, "Device atomic write unit: [%u, %u], THP %s, using xfs block size %u",
> + min, max, has_thp() ? "available" : "unavailable", bsize);
> +
> + snprintf(opt_bsize, sizeof(opt_bsize), "-bsize=%u", bsize);
> + fs_opts[0] = "-f";
> + fs_opts[1] = opt_bsize;
> + fs_opts[2] = NULL;
> + } else {
> + unsigned int cluster = MIN(max, 16 * bsize);
> +
> + if (cluster < bsize)
> + cluster = bsize;
> +
> + tst_res(TINFO, "Device atomic write unit: [%u, %u], using ext4 block size %u, cluster size %u",
> + min, max, bsize, cluster);
> +
> + snprintf(opt_bsize, sizeof(opt_bsize), "%u", bsize);
> + snprintf(opt_cluster, sizeof(opt_cluster), "%u", cluster);
> + fs_opts[0] = "-O";
> + fs_opts[1] = "bigalloc";
> + fs_opts[2] = "-b";
> + fs_opts[3] = opt_bsize;
> + fs_opts[4] = "-C";
> + fs_opts[5] = opt_cluster;
> + fs_opts[6] = NULL;
> + }
> +
> + SAFE_MKFS(tst_device->dev, tst_device->fs_type, fs_opts, NULL);
> +
> +mount_fs:
> +
> + TEST(mount(tst_device->dev, MNTPOINT, tst_device->fs_type, 0, NULL));
> + if (TST_RET) {
> + if (TST_ERR == EINVAL || TST_ERR == ENOSYS || TST_ERR == EOPNOTSUPP) {
> + if (bsize)
> + tst_brk(TCONF | TERRNO, "mount() of %s with block size %u not supported",
> + tst_device->fs_type, bsize);
> + tst_brk(TCONF | TERRNO, "mount() of %s not supported",
> + tst_device->fs_type);
> + }
> + tst_brk(TBROK | TERRNO, "mount(%s, %s, %s, 0, NULL) failed",
> + tst_device->dev, MNTPOINT, tst_device->fs_type);
> + }
> + mount_flag = 1;
> +
> + SAFE_STAT(MNTPOINT, &sb);
> +
> + data_buff = SAFE_MEMALIGN(sb.st_blksize, sb.st_blksize);
> + memset(data_buff, '@', sb.st_blksize);
> +
> + file_fd = SAFE_OPEN(TESTFILE, O_RDWR | O_CREAT | O_DIRECT, MODE);
> + SAFE_WRITE(SAFE_WRITE_ALL, file_fd, data_buff, sb.st_blksize);
> +}
> +
> +static void cleanup(void)
> +{
> + free(data_buff);
> +
> + if (file_fd != -1)
> + SAFE_CLOSE(file_fd);
> +
> + if (mount_flag)
> + tst_umount(MNTPOINT);
> +}
> +
> +static struct tst_test test = {
> + .test_all = verify_statx,
> + .setup = setup,
> + .cleanup = cleanup,
> + .min_kver = "6.13",
> + .needs_root = 1,
> + .needs_device = 1,
> + .needs_tmpdir = 1,
> + .mntpoint = MNTPOINT,
> + .bufs = (struct tst_buffers []) {
> + {&buff, .size = sizeof(*buff)},
> + {}
> + },
> + .filesystems = (struct tst_fs[]) {
> + {.type = "xfs"},
> + {.type = "ext4"},
> + {}
> + },
> +};
>
> ---
> base-commit: af1ad307f998b7f381bab065225df17390b91f77
> change-id: 20261027-statx-atomic-write-db54af9ef297
>
> Best regards,
> --
> Gaurav Pathak <gaurav.pathak@suse.com>
>
>
> --
> Mailing list info: https://lists.linux.it/listinfo/ltp
--
Cyril Hrubis
chrubis@suse.cz
--
Mailing list info: https://lists.linux.it/listinfo/ltp
prev parent reply other threads:[~2026-11-20 15:23 UTC|newest]
Thread overview: 13+ messages / expand[flat|nested] mbox.gz Atom feed top
2026-10-16 7:13 [LTP] [PATCH v7] syscalls/statx13: Add basic test for STATX_WRITE_ATOMIC on regular file Gaurav Pathak
2026-10-16 10:52 ` [LTP] " linuxtestproject.agent
2026-10-19 10:16 ` [LTP] [PATCH v8 0/1] statx: Add regression test for STATX_WRITE_ATOMIC on regular files Gaurav Pathak
2026-10-19 10:16 ` [LTP] [PATCH v8 1/1] " Gaurav Pathak
2026-10-19 10:28 ` [LTP] [PATCH v8 2/2] " Gaurav Pathak
2026-10-19 10:28 ` [LTP] [PATCH v8 1/2] syscalls/statx13: Add test for STATX_WRITE_ATOMIC on regular file Gaurav Pathak
2026-10-26 17:10 ` [LTP] [PATCH v9] " Gaurav Pathak
2026-10-26 21:30 ` [LTP] " linuxtestproject.agent
2026-10-27 7:06 ` [LTP] [PATCH v10] " Gaurav Pathak
2026-10-27 7:33 ` [LTP] " linuxtestproject.agent
2026-10-27 8:10 ` [LTP] [PATCH v11] " Gaurav Pathak
2026-10-27 12:19 ` [LTP] " linuxtestproject.agent
2026-11-20 15:24 ` Cyril Hrubis [this message]
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=awBmECbdo7iUCXPv@yuki.lan \
--to=chrubis@suse.cz \
--cc=gaurav.pathak@suse.com \
--cc=gpathak@suse.de \
--cc=ltp@lists.linux.it \
/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