Linux Test Project
 help / color / mirror / Atom feed
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

      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