[LTP] [PATCH v1] ioctl_fiemap01: New test for fiemap ioctl()

[LTP] [PATCH v1] ioctl_fiemap01: New test for fiemap ioctl()

[Wei Gao via ltp]

Fix: #535

Signed-off-by: Wei Gao <wegao@suse.com>
---
 runtest/syscalls                              |   2 +
 testcases/kernel/syscalls/ioctl/.gitignore    |   1 +
 .../kernel/syscalls/ioctl/ioctl_fiemap01.c    | 107 ++++++++++++++++++
 3 files changed, 110 insertions(+)
 create mode 100644 testcases/kernel/syscalls/ioctl/ioctl_fiemap01.c

diff --git a/runtest/syscalls b/runtest/syscalls
index 4152e1e5f..c7a0b2301 100644
--- a/runtest/syscalls
+++ b/runtest/syscalls
@@ -588,6 +588,8 @@ ioctl_ns07 ioctl_ns07
 
 ioctl_sg01 ioctl_sg01
 
+ioctl_fiemap01 ioctl_fiemap01
+
 inotify_init1_01 inotify_init1_01
 inotify_init1_02 inotify_init1_02
 
diff --git a/testcases/kernel/syscalls/ioctl/.gitignore b/testcases/kernel/syscalls/ioctl/.gitignore
index 5fff7a61d..64adcdfe6 100644
--- a/testcases/kernel/syscalls/ioctl/.gitignore
+++ b/testcases/kernel/syscalls/ioctl/.gitignore
@@ -22,3 +22,4 @@
 /ioctl_ns06
 /ioctl_ns07
 /ioctl_sg01
+/ioctl_fiemap01
diff --git a/testcases/kernel/syscalls/ioctl/ioctl_fiemap01.c b/testcases/kernel/syscalls/ioctl/ioctl_fiemap01.c
new file mode 100644
index 000000000..e0511667e
--- /dev/null
+++ b/testcases/kernel/syscalls/ioctl/ioctl_fiemap01.c
@@ -0,0 +1,107 @@
+// SPDX-License-Identifier: GPL-2.0-only
+/*
+ * Copyright (c) 2023 Wei Gao <wegao@suse.com>
+ */
+
+/*\
+ * [Description]
+ *
+ * Verify basic fiemap ioctl
+ *
+ */
+
+#include <linux/fs.h>
+#include <linux/fiemap.h>
+#include <stdlib.h>
+
+#include "tst_test.h"
+
+#define TESTFILE "testfile"
+#define NUM_EXTENT 2
+#define FILE_OFFSET ((rand() % 8 + 2) * getpagesize())
+
+static char *buf;
+
+static void print_extens(struct fiemap *fiemap)
+{
+
+	tst_res(TINFO, "File extent count: %u", fiemap->fm_mapped_extents);
+	for (unsigned int i = 0; i < fiemap->fm_mapped_extents; ++i) {
+		tst_res(TINFO, "Extent %u: Logical offset: %llu, Physical offset: %llu, flags: %u, Length: %llu",
+				i + 1,
+				fiemap->fm_extents[i].fe_logical,
+				fiemap->fm_extents[i].fe_physical,
+				fiemap->fm_extents[i].fe_flags,
+				fiemap->fm_extents[i].fe_length);
+	}
+}
+
+static void verify_ioctl(void)
+{
+	int fd;
+	struct fiemap *fiemap;
+
+	fd = SAFE_OPEN(TESTFILE, O_RDWR | O_CREAT, 0644);
+
+	fiemap = SAFE_MALLOC(sizeof(struct fiemap) + sizeof(struct fiemap_extent) * NUM_EXTENT);
+	fiemap->fm_start = 0;
+	fiemap->fm_length = ~0ULL;
+	fiemap->fm_extent_count = 1;
+
+	fiemap->fm_flags =  -1;
+	TST_EXP_FAIL(ioctl(fd, FS_IOC_FIEMAP, fiemap), EBADR);
+
+	fiemap->fm_flags =  0;
+	SAFE_IOCTL(fd, FS_IOC_FIEMAP, fiemap);
+	print_extens(fiemap);
+	if (fiemap->fm_mapped_extents == 0)
+		tst_res(TPASS, "Check fiemap iotct step1 pass");
+
+	SAFE_WRITE(SAFE_WRITE_ANY, fd, buf, getpagesize());
+	SAFE_IOCTL(fd, FS_IOC_FIEMAP, fiemap);
+	print_extens(fiemap);
+	if ((fiemap->fm_mapped_extents == 1) && (fiemap->fm_extents[0].fe_physical == 0))
+		tst_res(TPASS, "Check fiemap iotct step2 pass");
+
+	fiemap->fm_flags = FIEMAP_FLAG_SYNC;
+	SAFE_IOCTL(fd, FS_IOC_FIEMAP, fiemap);
+	print_extens(fiemap);
+	if ((fiemap->fm_extent_count == 1) &&
+		(fiemap->fm_extents[0].fe_flags == FIEMAP_EXTENT_LAST) &&
+		(fiemap->fm_extents[0].fe_physical > 0) &&
+		(fiemap->fm_extents[0].fe_length == (__u64)getpagesize()))
+		tst_res(TPASS, "Check fiemap iotct step3 pass");
+
+	fiemap->fm_extent_count = NUM_EXTENT;
+	srand(time(NULL));
+	SAFE_LSEEK(fd, FILE_OFFSET, SEEK_SET);
+	SAFE_WRITE(SAFE_WRITE_ALL, fd, buf, getpagesize());
+	SAFE_IOCTL(fd, FS_IOC_FIEMAP, fiemap);
+	print_extens(fiemap);
+	if ((fiemap->fm_extent_count == NUM_EXTENT) &&
+		(fiemap->fm_extents[NUM_EXTENT - 1].fe_flags == FIEMAP_EXTENT_LAST) &&
+		(fiemap->fm_extents[NUM_EXTENT - 1].fe_physical > 0) &&
+		(fiemap->fm_extents[NUM_EXTENT - 1].fe_length == (__u64)getpagesize()))
+		tst_res(TPASS, "Check fiemap iotct step4 pass");
+
+	free(fiemap);
+	close(fd);
+}
+
+static void setup(void)
+{
+	buf = SAFE_MALLOC(getpagesize());
+}
+
+static void cleanup(void)
+{
+	free(buf);
+}
+
+static struct tst_test test = {
+	.setup = setup,
+	.cleanup = cleanup,
+	.test_all = verify_ioctl,
+	.needs_root = 1,
+	.needs_tmpdir = 1,
+};
-- 
2.35.3


-- 
Mailing list info: https://lists.linux.it/listinfo/ltp

Re: [LTP] [PATCH v1] ioctl_fiemap01: New test for fiemap ioctl()

[Cyril Hrubis]

Hi!
> +static void print_extens(struct fiemap *fiemap)
> +{
> +
> +	tst_res(TINFO, "File extent count: %u", fiemap->fm_mapped_extents);
> +	for (unsigned int i = 0; i < fiemap->fm_mapped_extents; ++i) {
> +		tst_res(TINFO, "Extent %u: Logical offset: %llu, Physical offset: %llu, flags: %u, Length: %llu",
                          ^
			  This would probably be better TDEBUG that has
			  been recently introduced.
> +				i + 1,
> +				fiemap->fm_extents[i].fe_logical,
> +				fiemap->fm_extents[i].fe_physical,
> +				fiemap->fm_extents[i].fe_flags,
> +				fiemap->fm_extents[i].fe_length);
> +	}
> +}
> +
> +static void verify_ioctl(void)
> +{
> +	int fd;
> +	struct fiemap *fiemap;
> +
> +	fd = SAFE_OPEN(TESTFILE, O_RDWR | O_CREAT, 0644);
> +
> +	fiemap = SAFE_MALLOC(sizeof(struct fiemap) + sizeof(struct fiemap_extent) * NUM_EXTENT);
> +	fiemap->fm_start = 0;
> +	fiemap->fm_length = ~0ULL;
> +	fiemap->fm_extent_count = 1;
> +
> +	fiemap->fm_flags =  -1;
> +	TST_EXP_FAIL(ioctl(fd, FS_IOC_FIEMAP, fiemap), EBADR);
> +
> +	fiemap->fm_flags =  0;
> +	SAFE_IOCTL(fd, FS_IOC_FIEMAP, fiemap);
> +	print_extens(fiemap);
> +	if (fiemap->fm_mapped_extents == 0)
> +		tst_res(TPASS, "Check fiemap iotct step1 pass");

This is missing the TFAIL branch, also "step1 pass" is not good enough
description of the test, we should really describe what we were testing
for.

> +	SAFE_WRITE(SAFE_WRITE_ANY, fd, buf, getpagesize());
> +	SAFE_IOCTL(fd, FS_IOC_FIEMAP, fiemap);
> +	print_extens(fiemap);
> +	if ((fiemap->fm_mapped_extents == 1) && (fiemap->fm_extents[0].fe_physical == 0))
> +		tst_res(TPASS, "Check fiemap iotct step2 pass");

Here as well.

> +	fiemap->fm_flags = FIEMAP_FLAG_SYNC;
> +	SAFE_IOCTL(fd, FS_IOC_FIEMAP, fiemap);
> +	print_extens(fiemap);
> +	if ((fiemap->fm_extent_count == 1) &&
> +		(fiemap->fm_extents[0].fe_flags == FIEMAP_EXTENT_LAST) &&
> +		(fiemap->fm_extents[0].fe_physical > 0) &&
> +		(fiemap->fm_extents[0].fe_length == (__u64)getpagesize()))
> +		tst_res(TPASS, "Check fiemap iotct step3 pass");

And here as well.

> +	fiemap->fm_extent_count = NUM_EXTENT;
> +	srand(time(NULL));
> +	SAFE_LSEEK(fd, FILE_OFFSET, SEEK_SET);
> +	SAFE_WRITE(SAFE_WRITE_ALL, fd, buf, getpagesize());
> +	SAFE_IOCTL(fd, FS_IOC_FIEMAP, fiemap);
> +	print_extens(fiemap);
> +	if ((fiemap->fm_extent_count == NUM_EXTENT) &&
> +		(fiemap->fm_extents[NUM_EXTENT - 1].fe_flags == FIEMAP_EXTENT_LAST) &&
> +		(fiemap->fm_extents[NUM_EXTENT - 1].fe_physical > 0) &&
> +		(fiemap->fm_extents[NUM_EXTENT - 1].fe_length == (__u64)getpagesize()))
> +		tst_res(TPASS, "Check fiemap iotct step4 pass");

And here as well.

> +	free(fiemap);
> +	close(fd);

SAFE_CLOSE() plase.

I suppose that we have to unlink the file so that the test work with -i
2.

> +}
> +
> +static void setup(void)
> +{
> +	buf = SAFE_MALLOC(getpagesize());
> +}
> +
> +static void cleanup(void)
> +{
> +	free(buf);
> +}
> +
> +static struct tst_test test = {
> +	.setup = setup,
> +	.cleanup = cleanup,
> +	.test_all = verify_ioctl,
> +	.needs_root = 1,
> +	.needs_tmpdir = 1,
> +};
> -- 
> 2.35.3
> 
> 
> -- 
> Mailing list info: https://lists.linux.it/listinfo/ltp

-- 
Cyril Hrubis
chrubis@suse.cz

-- 
Mailing list info: https://lists.linux.it/listinfo/ltp

[LTP] [PATCH v2] ioctl_fiemap01: New test for fiemap ioctl()

[Wei Gao via ltp]

Fixes: #535

Signed-off-by: Wei Gao <wegao@suse.com>
---
 runtest/syscalls                              |   2 +
 testcases/kernel/syscalls/ioctl/.gitignore    |   1 +
 .../kernel/syscalls/ioctl/ioctl_fiemap01.c    | 116 ++++++++++++++++++
 3 files changed, 119 insertions(+)
 create mode 100644 testcases/kernel/syscalls/ioctl/ioctl_fiemap01.c

diff --git a/runtest/syscalls b/runtest/syscalls
index 6e2407879..4e6ce5aef 100644
--- a/runtest/syscalls
+++ b/runtest/syscalls
@@ -589,6 +589,8 @@ ioctl_ns07 ioctl_ns07
 
 ioctl_sg01 ioctl_sg01
 
+ioctl_fiemap01 ioctl_fiemap01
+
 inotify_init1_01 inotify_init1_01
 inotify_init1_02 inotify_init1_02
 
diff --git a/testcases/kernel/syscalls/ioctl/.gitignore b/testcases/kernel/syscalls/ioctl/.gitignore
index 5fff7a61d..64adcdfe6 100644
--- a/testcases/kernel/syscalls/ioctl/.gitignore
+++ b/testcases/kernel/syscalls/ioctl/.gitignore
@@ -22,3 +22,4 @@
 /ioctl_ns06
 /ioctl_ns07
 /ioctl_sg01
+/ioctl_fiemap01
diff --git a/testcases/kernel/syscalls/ioctl/ioctl_fiemap01.c b/testcases/kernel/syscalls/ioctl/ioctl_fiemap01.c
new file mode 100644
index 000000000..a626bb03c
--- /dev/null
+++ b/testcases/kernel/syscalls/ioctl/ioctl_fiemap01.c
@@ -0,0 +1,116 @@
+// SPDX-License-Identifier: GPL-2.0-only
+/*
+ * Copyright (c) 2023 Wei Gao <wegao@suse.com>
+ */
+
+/*\
+ * [Description]
+ *
+ * Verify basic fiemap ioctl
+ *
+ */
+
+#include <linux/fs.h>
+#include <linux/fiemap.h>
+#include <stdlib.h>
+
+#include "tst_test.h"
+
+#define TESTFILE "testfile"
+#define NUM_EXTENT 2
+#define FILE_OFFSET ((rand() % 8 + 2) * getpagesize())
+
+static char *buf;
+
+static void print_extens(struct fiemap *fiemap)
+{
+
+	tst_res(TDEBUG, "File extent count: %u", fiemap->fm_mapped_extents);
+	for (unsigned int i = 0; i < fiemap->fm_mapped_extents; ++i) {
+		tst_res(TDEBUG, "Extent %u: Logical offset: %llu, Physical offset: %llu, flags: %u, Length: %llu",
+				i + 1,
+				fiemap->fm_extents[i].fe_logical,
+				fiemap->fm_extents[i].fe_physical,
+				fiemap->fm_extents[i].fe_flags,
+				fiemap->fm_extents[i].fe_length);
+	}
+}
+
+static void verify_ioctl(void)
+{
+	int fd;
+	struct fiemap *fiemap;
+
+	fd = SAFE_OPEN(TESTFILE, O_RDWR | O_CREAT, 0644);
+
+	fiemap = SAFE_MALLOC(sizeof(struct fiemap) + sizeof(struct fiemap_extent) * NUM_EXTENT);
+	fiemap->fm_start = 0;
+	fiemap->fm_length = ~0ULL;
+	fiemap->fm_extent_count = 1;
+
+	fiemap->fm_flags =  -1;
+	TST_EXP_FAIL(ioctl(fd, FS_IOC_FIEMAP, fiemap), EBADR);
+
+	fiemap->fm_flags =  0;
+	SAFE_IOCTL(fd, FS_IOC_FIEMAP, fiemap);
+	print_extens(fiemap);
+	if (fiemap->fm_mapped_extents == 0)
+		tst_res(TPASS, "Check fiemap iotct zero fm_mapped_extents pass");
+	else
+		tst_res(TFAIL, "Check fiemap iotct zero fm_mapped_extents failed");
+
+	SAFE_WRITE(SAFE_WRITE_ANY, fd, buf, getpagesize());
+	SAFE_IOCTL(fd, FS_IOC_FIEMAP, fiemap);
+	print_extens(fiemap);
+	if ((fiemap->fm_mapped_extents == 1) && (fiemap->fm_extents[0].fe_physical == 0))
+		tst_res(TPASS, "Check fiemap iotct one fm_mapped_extents pass");
+	else
+		tst_res(TFAIL, "Check fiemap iotct one fm_mapped_extents failed");
+
+	fiemap->fm_flags = FIEMAP_FLAG_SYNC;
+	SAFE_IOCTL(fd, FS_IOC_FIEMAP, fiemap);
+	print_extens(fiemap);
+	if ((fiemap->fm_mapped_extents == 1) &&
+		(fiemap->fm_extents[0].fe_flags == FIEMAP_EXTENT_LAST) &&
+		(fiemap->fm_extents[0].fe_physical > 0) &&
+		(fiemap->fm_extents[0].fe_length == (__u64)getpagesize()))
+		tst_res(TPASS, "Check fiemap iotct FIEMAP_FLAG_SYNC fm_flags pass");
+	else
+		tst_res(TFAIL, "Check fiemap iotct FIEMAP_FLAG_SYNC fm_flags failed");
+
+	fiemap->fm_extent_count = NUM_EXTENT;
+	srand(time(NULL));
+	SAFE_LSEEK(fd, FILE_OFFSET, SEEK_SET);
+	SAFE_WRITE(SAFE_WRITE_ALL, fd, buf, getpagesize());
+	SAFE_IOCTL(fd, FS_IOC_FIEMAP, fiemap);
+	print_extens(fiemap);
+	if ((fiemap->fm_mapped_extents == NUM_EXTENT) &&
+		(fiemap->fm_extents[NUM_EXTENT - 1].fe_flags == FIEMAP_EXTENT_LAST) &&
+		(fiemap->fm_extents[NUM_EXTENT - 1].fe_physical > 0) &&
+		(fiemap->fm_extents[NUM_EXTENT - 1].fe_length == (__u64)getpagesize()))
+		tst_res(TPASS, "Check fiemap iotct multiple fm_mapped_extents pass");
+	else
+		tst_res(TFAIL, "Check fiemap iotct multiple fm_mapped_extents failed");
+
+	free(fiemap);
+	SAFE_CLOSE(fd);
+	unlink(TESTFILE);
+}
+
+static void setup(void)
+{
+	buf = SAFE_MALLOC(getpagesize());
+}
+
+static void cleanup(void)
+{
+	free(buf);
+}
+
+static struct tst_test test = {
+	.setup = setup,
+	.cleanup = cleanup,
+	.test_all = verify_ioctl,
+	.needs_root = 1,
+	.needs_tmpdir = 1,
+};
-- 
2.35.3


-- 
Mailing list info: https://lists.linux.it/listinfo/ltp

Re: [LTP] [PATCH v2] ioctl_fiemap01: New test for fiemap ioctl()

[Petr Vorel]

Hi Wei,

> Fixes: #535

> diff --git a/testcases/kernel/syscalls/ioctl/ioctl_fiemap01.c b/testcases/kernel/syscalls/ioctl/ioctl_fiemap01.c
> new file mode 100644
> index 000000000..a626bb03c
> --- /dev/null
> +++ b/testcases/kernel/syscalls/ioctl/ioctl_fiemap01.c
> @@ -0,0 +1,116 @@
> +// SPDX-License-Identifier: GPL-2.0-only
> +/*
> + * Copyright (c) 2023 Wei Gao <wegao@suse.com>
> + */
> +
> +/*\
> + * [Description]
> + *
> + * Verify basic fiemap ioctl
> + *
nit: missing space and dot at the end.
> + */
> +
> +#include <linux/fs.h>
> +#include <linux/fiemap.h>
> +#include <stdlib.h>
> +
> +#include "tst_test.h"
> +
> +#define TESTFILE "testfile"
> +#define NUM_EXTENT 2
> +#define FILE_OFFSET ((rand() % 8 + 2) * getpagesize())
> +
> +static char *buf;
> +
> +static void print_extens(struct fiemap *fiemap)
> +{
> +
nit: please no space above.
> +	tst_res(TDEBUG, "File extent count: %u", fiemap->fm_mapped_extents);
nit: please add space here (readability)
> +	for (unsigned int i = 0; i < fiemap->fm_mapped_extents; ++i) {
> +		tst_res(TDEBUG, "Extent %u: Logical offset: %llu, Physical offset: %llu, flags: %u, Length: %llu",
> +				i + 1,
> +				fiemap->fm_extents[i].fe_logical,
> +				fiemap->fm_extents[i].fe_physical,
> +				fiemap->fm_extents[i].fe_flags,
> +				fiemap->fm_extents[i].fe_length);
> +	}
> +}
> +
> +static void verify_ioctl(void)
> +{
> +	int fd;
> +	struct fiemap *fiemap;
> +
> +	fd = SAFE_OPEN(TESTFILE, O_RDWR | O_CREAT, 0644);
> +
> +	fiemap = SAFE_MALLOC(sizeof(struct fiemap) + sizeof(struct fiemap_extent) * NUM_EXTENT);
> +	fiemap->fm_start = 0;
> +	fiemap->fm_length = ~0ULL;
> +	fiemap->fm_extent_count = 1;
> +
> +	fiemap->fm_flags =  -1;
> +	TST_EXP_FAIL(ioctl(fd, FS_IOC_FIEMAP, fiemap), EBADR);

I get on Tumbleweed with 6.8.0-rc4-1.g9b23bf2-default EOPNOTSUPP:
ioctl_fiemap01.c:52: TFAIL: ioctl(fd, FS_IOC_FIEMAP, fiemap) expected EBADR: EOPNOTSUPP (95)
What is the missing dependency for FS_IOC_FIEMAP? Or is there wrong fiemap use
which causes that?

> +
> +	fiemap->fm_flags =  0;
> +	SAFE_IOCTL(fd, FS_IOC_FIEMAP, fiemap);
And on the same kernel another EOPNOTSUPP:

ioctl_fiemap01.c:55: TBROK: ioctl(3,((((2U|1U) << (((0+8)+8)+14)) | ((('f')) << (0+8)) | (((11)) << 0) | ((((sizeof(struct fiemap)))) << ((0+8)+8)))),...) failed: EOPNOTSUPP (95)
> +	print_extens(fiemap);
> +	if (fiemap->fm_mapped_extents == 0)
> +		tst_res(TPASS, "Check fiemap iotct zero fm_mapped_extents pass");
s/iotct/ioctl/

> +	else
> +		tst_res(TFAIL, "Check fiemap iotct zero fm_mapped_extents failed");
s/iotct/ioctl/
> +
> +	SAFE_WRITE(SAFE_WRITE_ANY, fd, buf, getpagesize());
> +	SAFE_IOCTL(fd, FS_IOC_FIEMAP, fiemap);
> +	print_extens(fiemap);
Maybe print only on failure?
> +	if ((fiemap->fm_mapped_extents == 1) && (fiemap->fm_extents[0].fe_physical == 0))
NOTE: brackets are not needed (== has higher precedence than &&), thus:
	if (fiemap->fm_mapped_extents == 1 && fiemap->fm_extents[0].fe_physical == 0)

> +		tst_res(TPASS, "Check fiemap iotct one fm_mapped_extents pass");
s/iotct/ioctl/
> +	else
> +		tst_res(TFAIL, "Check fiemap iotct one fm_mapped_extents failed");
s/iotct/ioctl/
> +
> +	fiemap->fm_flags = FIEMAP_FLAG_SYNC;
> +	SAFE_IOCTL(fd, FS_IOC_FIEMAP, fiemap);
> +	print_extens(fiemap);
> +	if ((fiemap->fm_mapped_extents == 1) &&
nit: again == does not need to be in ()
> +		(fiemap->fm_extents[0].fe_flags == FIEMAP_EXTENT_LAST) &&
> +		(fiemap->fm_extents[0].fe_physical > 0) &&
> +		(fiemap->fm_extents[0].fe_length == (__u64)getpagesize()))
> +		tst_res(TPASS, "Check fiemap iotct FIEMAP_FLAG_SYNC fm_flags pass");
s/iotct/ioctl/
> +	else
> +		tst_res(TFAIL, "Check fiemap iotct FIEMAP_FLAG_SYNC fm_flags failed");
s/iotct/ioctl/
There are 4x checks, I guess instead it would be worth to write what exactly failed.

> +
> +	fiemap->fm_extent_count = NUM_EXTENT;
> +	srand(time(NULL));
> +	SAFE_LSEEK(fd, FILE_OFFSET, SEEK_SET);
> +	SAFE_WRITE(SAFE_WRITE_ALL, fd, buf, getpagesize());
> +	SAFE_IOCTL(fd, FS_IOC_FIEMAP, fiemap);
> +	print_extens(fiemap);
> +	if ((fiemap->fm_mapped_extents == NUM_EXTENT) &&
nit: If this check was repeated more than twice, I would put it into separate
function.
> +		(fiemap->fm_extents[NUM_EXTENT - 1].fe_flags == FIEMAP_EXTENT_LAST) &&
> +		(fiemap->fm_extents[NUM_EXTENT - 1].fe_physical > 0) &&
> +		(fiemap->fm_extents[NUM_EXTENT - 1].fe_length == (__u64)getpagesize()))
> +		tst_res(TPASS, "Check fiemap iotct multiple fm_mapped_extents pass");
> +	else
> +		tst_res(TFAIL, "Check fiemap iotct multiple fm_mapped_extents failed");
> +
> +	free(fiemap);
> +	SAFE_CLOSE(fd);
> +	unlink(TESTFILE);
> +}
...

Kind regards,
Petr

-- 
Mailing list info: https://lists.linux.it/listinfo/ltp

Re: [LTP] [PATCH v2] ioctl_fiemap01: New test for fiemap ioctl()

[Wei Gao via ltp]

On Wed, Feb 28, 2024 at 06:07:29PM +0100, Petr Vorel wrote:
> Hi Wei,
> 
> > Fixes: #535
> 
> > diff --git a/testcases/kernel/syscalls/ioctl/ioctl_fiemap01.c b/testcases/kernel/syscalls/ioctl/ioctl_fiemap01.c
> > new file mode 100644
> > index 000000000..a626bb03c
> > --- /dev/null
> > +++ b/testcases/kernel/syscalls/ioctl/ioctl_fiemap01.c
> > @@ -0,0 +1,116 @@
> > +// SPDX-License-Identifier: GPL-2.0-only
> > +/*
> > + * Copyright (c) 2023 Wei Gao <wegao@suse.com>
> > + */
> > +
> > +/*\
> > + * [Description]
> > + *
> > + * Verify basic fiemap ioctl
> > + *
> nit: missing space and dot at the end.
> > + */
> > +
> > +#include <linux/fs.h>
> > +#include <linux/fiemap.h>
> > +#include <stdlib.h>
> > +
> > +#include "tst_test.h"
> > +
> > +#define TESTFILE "testfile"
> > +#define NUM_EXTENT 2
> > +#define FILE_OFFSET ((rand() % 8 + 2) * getpagesize())
> > +
> > +static char *buf;
> > +
> > +static void print_extens(struct fiemap *fiemap)
> > +{
> > +
> nit: please no space above.
> > +	tst_res(TDEBUG, "File extent count: %u", fiemap->fm_mapped_extents);
> nit: please add space here (readability)
> > +	for (unsigned int i = 0; i < fiemap->fm_mapped_extents; ++i) {
> > +		tst_res(TDEBUG, "Extent %u: Logical offset: %llu, Physical offset: %llu, flags: %u, Length: %llu",
> > +				i + 1,
> > +				fiemap->fm_extents[i].fe_logical,
> > +				fiemap->fm_extents[i].fe_physical,
> > +				fiemap->fm_extents[i].fe_flags,
> > +				fiemap->fm_extents[i].fe_length);
> > +	}
> > +}
> > +
> > +static void verify_ioctl(void)
> > +{
> > +	int fd;
> > +	struct fiemap *fiemap;
> > +
> > +	fd = SAFE_OPEN(TESTFILE, O_RDWR | O_CREAT, 0644);
> > +
> > +	fiemap = SAFE_MALLOC(sizeof(struct fiemap) + sizeof(struct fiemap_extent) * NUM_EXTENT);
> > +	fiemap->fm_start = 0;
> > +	fiemap->fm_length = ~0ULL;
> > +	fiemap->fm_extent_count = 1;
> > +
> > +	fiemap->fm_flags =  -1;
> > +	TST_EXP_FAIL(ioctl(fd, FS_IOC_FIEMAP, fiemap), EBADR);
> 
> I get on Tumbleweed with 6.8.0-rc4-1.g9b23bf2-default EOPNOTSUPP:
> ioctl_fiemap01.c:52: TFAIL: ioctl(fd, FS_IOC_FIEMAP, fiemap) expected EBADR: EOPNOTSUPP (95)
> What is the missing dependency for FS_IOC_FIEMAP? Or is there wrong fiemap use
> which causes that?
Thanks for your test and i also reproduce this issue.
This is caused by Tumbleweed mount tmpfs on /tmp and tmpfs seems not support fiemap action.
tmpfs on /tmp type tmpfs (rw,nosuid,nodev,size=494452k,nr_inodes=1048576,inode64)

I will sent new patch for cover all supported filesystem.
> 
> > +
> > +	fiemap->fm_flags =  0;
> > +	SAFE_IOCTL(fd, FS_IOC_FIEMAP, fiemap);
> And on the same kernel another EOPNOTSUPP:
> 
> ioctl_fiemap01.c:55: TBROK: ioctl(3,((((2U|1U) << (((0+8)+8)+14)) | ((('f')) << (0+8)) | (((11)) << 0) | ((((sizeof(struct fiemap)))) << ((0+8)+8)))),...) failed: EOPNOTSUPP (95)
> > +	print_extens(fiemap);
> > +	if (fiemap->fm_mapped_extents == 0)
> > +		tst_res(TPASS, "Check fiemap iotct zero fm_mapped_extents pass");
> s/iotct/ioctl/
> 
> > +	else
> > +		tst_res(TFAIL, "Check fiemap iotct zero fm_mapped_extents failed");
> s/iotct/ioctl/
> > +
> > +	SAFE_WRITE(SAFE_WRITE_ANY, fd, buf, getpagesize());
> > +	SAFE_IOCTL(fd, FS_IOC_FIEMAP, fiemap);
> > +	print_extens(fiemap);
> Maybe print only on failure?
> > +	if ((fiemap->fm_mapped_extents == 1) && (fiemap->fm_extents[0].fe_physical == 0))
> NOTE: brackets are not needed (== has higher precedence than &&), thus:
> 	if (fiemap->fm_mapped_extents == 1 && fiemap->fm_extents[0].fe_physical == 0)
> 
> > +		tst_res(TPASS, "Check fiemap iotct one fm_mapped_extents pass");
> s/iotct/ioctl/
> > +	else
> > +		tst_res(TFAIL, "Check fiemap iotct one fm_mapped_extents failed");
> s/iotct/ioctl/
> > +
> > +	fiemap->fm_flags = FIEMAP_FLAG_SYNC;
> > +	SAFE_IOCTL(fd, FS_IOC_FIEMAP, fiemap);
> > +	print_extens(fiemap);
> > +	if ((fiemap->fm_mapped_extents == 1) &&
> nit: again == does not need to be in ()
> > +		(fiemap->fm_extents[0].fe_flags == FIEMAP_EXTENT_LAST) &&
> > +		(fiemap->fm_extents[0].fe_physical > 0) &&
> > +		(fiemap->fm_extents[0].fe_length == (__u64)getpagesize()))
> > +		tst_res(TPASS, "Check fiemap iotct FIEMAP_FLAG_SYNC fm_flags pass");
> s/iotct/ioctl/
> > +	else
> > +		tst_res(TFAIL, "Check fiemap iotct FIEMAP_FLAG_SYNC fm_flags failed");
> s/iotct/ioctl/
> There are 4x checks, I guess instead it would be worth to write what exactly failed.
> 
> > +
> > +	fiemap->fm_extent_count = NUM_EXTENT;
> > +	srand(time(NULL));
> > +	SAFE_LSEEK(fd, FILE_OFFSET, SEEK_SET);
> > +	SAFE_WRITE(SAFE_WRITE_ALL, fd, buf, getpagesize());
> > +	SAFE_IOCTL(fd, FS_IOC_FIEMAP, fiemap);
> > +	print_extens(fiemap);
> > +	if ((fiemap->fm_mapped_extents == NUM_EXTENT) &&
> nit: If this check was repeated more than twice, I would put it into separate
> function.
> > +		(fiemap->fm_extents[NUM_EXTENT - 1].fe_flags == FIEMAP_EXTENT_LAST) &&
> > +		(fiemap->fm_extents[NUM_EXTENT - 1].fe_physical > 0) &&
> > +		(fiemap->fm_extents[NUM_EXTENT - 1].fe_length == (__u64)getpagesize()))
> > +		tst_res(TPASS, "Check fiemap iotct multiple fm_mapped_extents pass");
> > +	else
> > +		tst_res(TFAIL, "Check fiemap iotct multiple fm_mapped_extents failed");
> > +
> > +	free(fiemap);
> > +	SAFE_CLOSE(fd);
> > +	unlink(TESTFILE);
> > +}
> ...
> 
> Kind regards,
> Petr

-- 
Mailing list info: https://lists.linux.it/listinfo/ltp

Re: [LTP] [PATCH v2] ioctl_fiemap01: New test for fiemap ioctl()

[Petr Vorel]

Hi Wei,

...
> > > +	fiemap->fm_flags =  -1;
> > > +	TST_EXP_FAIL(ioctl(fd, FS_IOC_FIEMAP, fiemap), EBADR);

> > I get on Tumbleweed with 6.8.0-rc4-1.g9b23bf2-default EOPNOTSUPP:
> > ioctl_fiemap01.c:52: TFAIL: ioctl(fd, FS_IOC_FIEMAP, fiemap) expected EBADR: EOPNOTSUPP (95)
> > What is the missing dependency for FS_IOC_FIEMAP? Or is there wrong fiemap use
> > which causes that?
> Thanks for your test and i also reproduce this issue.
> This is caused by Tumbleweed mount tmpfs on /tmp and tmpfs seems not support fiemap action.
> tmpfs on /tmp type tmpfs (rw,nosuid,nodev,size=494452k,nr_inodes=1048576,inode64)

+1. You probably knows that you need .skip_filesystems, which works even
.all_filesystems is not set.

	.skip_filesystems = (const char *const []) {
		"tmpfs",
		NULL
	},

But actually when this is filesystem dependent, I guess .all_filesystems = 1
would make sense, right?

> I will sent new patch for cover all supported filesystem.

I suppose you agree :).

Kind regards,
Petr

-- 
Mailing list info: https://lists.linux.it/listinfo/ltp

Re: [LTP] [PATCH v2] ioctl_fiemap01: New test for fiemap ioctl()

[Wei Gao via ltp]

On Fri, Mar 29, 2024 at 10:32:39PM +0100, Petr Vorel wrote:
> Hi Wei,
> 
> ...
> > > > +	fiemap->fm_flags =  -1;
> > > > +	TST_EXP_FAIL(ioctl(fd, FS_IOC_FIEMAP, fiemap), EBADR);
> 
> > > I get on Tumbleweed with 6.8.0-rc4-1.g9b23bf2-default EOPNOTSUPP:
> > > ioctl_fiemap01.c:52: TFAIL: ioctl(fd, FS_IOC_FIEMAP, fiemap) expected EBADR: EOPNOTSUPP (95)
> > > What is the missing dependency for FS_IOC_FIEMAP? Or is there wrong fiemap use
> > > which causes that?
> > Thanks for your test and i also reproduce this issue.
> > This is caused by Tumbleweed mount tmpfs on /tmp and tmpfs seems not support fiemap action.
> > tmpfs on /tmp type tmpfs (rw,nosuid,nodev,size=494452k,nr_inodes=1048576,inode64)
> 
> +1. You probably knows that you need .skip_filesystems, which works even
> .all_filesystems is not set.
> 
> 	.skip_filesystems = (const char *const []) {
> 		"tmpfs",
> 		NULL
> 	},
> 
> But actually when this is filesystem dependent, I guess .all_filesystems = 1
> would make sense, right?
> 
> > I will sent new patch for cover all supported filesystem.
> 
> I suppose you agree :).
Sure!
New draft patch will try to cover all filesystem.

The new patch has one more thing need improve, you suggest print_extens
only on failure, when i start using TST_EXP_EXPR i can not get return result.
Any suggestion or example code handle this in clean way or we can keep 
current implementation?
NOTE: print_extens currently control by TDEBUG.

Thanks a lot :)

> 
> Kind regards,
> Petr

-- 
Mailing list info: https://lists.linux.it/listinfo/ltp

[LTP] [PATCH v3] ioctl_fiemap01: New test for fiemap ioctl()

[Wei Gao via ltp]

Fixes: #535

Signed-off-by: Wei Gao <wegao@suse.com>
---
 runtest/syscalls                              |   2 +
 testcases/kernel/syscalls/ioctl/.gitignore    |   1 +
 .../kernel/syscalls/ioctl/ioctl_fiemap01.c    | 110 ++++++++++++++++++
 3 files changed, 113 insertions(+)
 create mode 100644 testcases/kernel/syscalls/ioctl/ioctl_fiemap01.c

diff --git a/runtest/syscalls b/runtest/syscalls
index 6e2407879..4e6ce5aef 100644
--- a/runtest/syscalls
+++ b/runtest/syscalls
@@ -589,6 +589,8 @@ ioctl_ns07 ioctl_ns07
 
 ioctl_sg01 ioctl_sg01
 
+ioctl_fiemap01 ioctl_fiemap01
+
 inotify_init1_01 inotify_init1_01
 inotify_init1_02 inotify_init1_02
 
diff --git a/testcases/kernel/syscalls/ioctl/.gitignore b/testcases/kernel/syscalls/ioctl/.gitignore
index 5fff7a61d..64adcdfe6 100644
--- a/testcases/kernel/syscalls/ioctl/.gitignore
+++ b/testcases/kernel/syscalls/ioctl/.gitignore
@@ -22,3 +22,4 @@
 /ioctl_ns06
 /ioctl_ns07
 /ioctl_sg01
+/ioctl_fiemap01
diff --git a/testcases/kernel/syscalls/ioctl/ioctl_fiemap01.c b/testcases/kernel/syscalls/ioctl/ioctl_fiemap01.c
new file mode 100644
index 000000000..b81842c6a
--- /dev/null
+++ b/testcases/kernel/syscalls/ioctl/ioctl_fiemap01.c
@@ -0,0 +1,110 @@
+// SPDX-License-Identifier: GPL-2.0-only
+/*
+ * Copyright (c) 2023 Wei Gao <wegao@suse.com>
+ */
+
+/*\
+ * [Description]
+ *
+ * Verify basic fiemap ioctl.
+ */
+
+#include <linux/fs.h>
+#include <linux/fiemap.h>
+#include <stdlib.h>
+#include <sys/statvfs.h>
+
+#include "tst_test.h"
+
+#define TMPDIR "mntdir"
+#define TESTFILE "testfile"
+#define NUM_EXTENT 3
+
+static void print_extens(struct fiemap *fiemap)
+{
+	tst_res(TDEBUG, "File extent count: %u", fiemap->fm_mapped_extents);
+
+	for (unsigned int i = 0; i < fiemap->fm_mapped_extents; ++i) {
+		tst_res(TDEBUG, "Extent %u: Logical offset: %llu, Physical offset: %llu, flags: %u, Length: %llu",
+				i + 1,
+				fiemap->fm_extents[i].fe_logical,
+				fiemap->fm_extents[i].fe_physical,
+				fiemap->fm_extents[i].fe_flags,
+				fiemap->fm_extents[i].fe_length);
+	}
+}
+
+static void check_extent(struct fiemap *fiemap, unsigned int fm_mapped_extents, int index_extents, int fe_flags, unsigned int min_fe_physical, unsigned int fe_length)
+{
+	TST_EXP_EXPR(fiemap->fm_mapped_extents == fm_mapped_extents,
+		"Check extent fm_mapped_extents is %d", fm_mapped_extents);
+	TST_EXP_EXPR(fiemap->fm_extents[index_extents].fe_flags & fe_flags,
+		"Check fe_flags is %d", fe_flags);
+	TST_EXP_EXPR(fiemap->fm_extents[index_extents].fe_physical >= min_fe_physical,
+		"Check fe_physical > %d", min_fe_physical);
+	TST_EXP_EXPR(fiemap->fm_extents[index_extents].fe_length == fe_length,
+		"Check fe_length is %d", fe_length);
+}
+
+static void verify_ioctl(void)
+{
+	int fd;
+	struct fiemap *fiemap;
+	struct statvfs fs_info;
+	unsigned long blk_size;
+
+	SAFE_CHDIR(TMPDIR);
+	fd = SAFE_OPEN(TESTFILE, O_RDWR | O_CREAT, 0644);
+
+	TST_EXP_PASS(statvfs(".", &fs_info));
+
+	blk_size = fs_info.f_bsize;
+
+	fiemap = SAFE_MALLOC(sizeof(struct fiemap) + sizeof(struct fiemap_extent) * NUM_EXTENT);
+	fiemap->fm_start = 0;
+	fiemap->fm_length = ~0ULL;
+	fiemap->fm_extent_count = 1;
+
+	fiemap->fm_flags =  -1;
+	TST_EXP_FAIL(ioctl(fd, FS_IOC_FIEMAP, fiemap), EBADR);
+
+	fiemap->fm_flags =  0;
+	TST_EXP_PASS(ioctl(fd, FS_IOC_FIEMAP, fiemap));
+	print_extens(fiemap);
+	TST_EXP_EXPR(fiemap->fm_mapped_extents == 0,
+		"Check extent fm_mapped_extents is 0");
+
+	char *buf = SAFE_MALLOC(blk_size);
+
+	SAFE_WRITE(SAFE_WRITE_ANY, fd, buf, blk_size);
+	fiemap->fm_flags = FIEMAP_FLAG_SYNC;
+	TST_EXP_PASS(ioctl(fd, FS_IOC_FIEMAP, fiemap));
+	print_extens(fiemap);
+	check_extent(fiemap, 1, 0, FIEMAP_EXTENT_LAST, 1, blk_size);
+
+	fiemap->fm_extent_count = NUM_EXTENT;
+	SAFE_LSEEK(fd, 2 * blk_size, SEEK_SET);
+	SAFE_WRITE(SAFE_WRITE_ALL, fd, buf, blk_size);
+	SAFE_LSEEK(fd, 4 * blk_size, SEEK_SET);
+	SAFE_WRITE(SAFE_WRITE_ALL, fd, buf, blk_size);
+	TST_EXP_PASS(ioctl(fd, FS_IOC_FIEMAP, fiemap));
+	print_extens(fiemap);
+	check_extent(fiemap, NUM_EXTENT, NUM_EXTENT - 1, FIEMAP_EXTENT_LAST, 1, blk_size);
+
+	free(buf);
+	free(fiemap);
+	SAFE_CLOSE(fd);
+	unlink(TESTFILE);
+}
+
+static struct tst_test test = {
+	.mount_device = 1,
+	.mntpoint = TMPDIR,
+	.all_filesystems = 1,
+	.skip_filesystems = (const char *const[]) {
+		"exfat", "vfat", "fuse", "ntfs", "tmpfs", NULL
+	},
+	.test_all = verify_ioctl,
+	.needs_root = 1,
+	.needs_tmpdir = 1,
+};
-- 
2.35.3


-- 
Mailing list info: https://lists.linux.it/listinfo/ltp

Re: [LTP] [PATCH v3] ioctl_fiemap01: New test for fiemap ioctl()

[Petr Vorel]

Hi Wei,

> +#define TMPDIR "mntdir"
very nit: We usually use MNTPOINT for .mntpoint
#define MNTPOINT   "mntpoint"

(I even tried to get rid of these defines:
https://patchwork.ozlabs.org/project/ltp/list/?series=393028 .)

> +#define TESTFILE "testfile"
> +#define NUM_EXTENT 3
> +
> +static void print_extens(struct fiemap *fiemap)
> +{
> +	tst_res(TDEBUG, "File extent count: %u", fiemap->fm_mapped_extents);
> +
> +	for (unsigned int i = 0; i < fiemap->fm_mapped_extents; ++i) {
> +		tst_res(TDEBUG, "Extent %u: Logical offset: %llu, Physical offset: %llu, flags: %u, Length: %llu",
> +				i + 1,
> +				fiemap->fm_extents[i].fe_logical,
> +				fiemap->fm_extents[i].fe_physical,
> +				fiemap->fm_extents[i].fe_flags,
> +				fiemap->fm_extents[i].fe_length);
> +	}
> +}
> +
> +static void check_extent(struct fiemap *fiemap, unsigned int fm_mapped_extents, int index_extents, int fe_flags, unsigned int min_fe_physical, unsigned int fe_length)
> +{
> +	TST_EXP_EXPR(fiemap->fm_mapped_extents == fm_mapped_extents,
> +		"Check extent fm_mapped_extents is %d", fm_mapped_extents);
nit: space here (and below) would be more readable for me.
> +	TST_EXP_EXPR(fiemap->fm_extents[index_extents].fe_flags & fe_flags,
> +		"Check fe_flags is %d", fe_flags);
> +	TST_EXP_EXPR(fiemap->fm_extents[index_extents].fe_physical >= min_fe_physical,
> +		"Check fe_physical > %d", min_fe_physical);
> +	TST_EXP_EXPR(fiemap->fm_extents[index_extents].fe_length == fe_length,
> +		"Check fe_length is %d", fe_length);
> +}
> +
> +static void verify_ioctl(void)
> +{
> +	int fd;
> +	struct fiemap *fiemap;
> +	struct statvfs fs_info;
> +	unsigned long blk_size;
> +
> +	SAFE_CHDIR(TMPDIR);
> +	fd = SAFE_OPEN(TESTFILE, O_RDWR | O_CREAT, 0644);
> +
> +	TST_EXP_PASS(statvfs(".", &fs_info));

I'd here jut use:
if (statvfs(".", &fs_info) != 0)
	tst_brk(TBROK, "statvfs failed");

Why? IMHO all TEST() and TST_EXP_PASS() should be used for the subject of
testing.

(We don't have safe_statvfs(), but it'd be needed just on 3 places.)

> +	blk_size = fs_info.f_bsize;
> +
> +	fiemap = SAFE_MALLOC(sizeof(struct fiemap) + sizeof(struct fiemap_extent) * NUM_EXTENT);
> +	fiemap->fm_start = 0;
> +	fiemap->fm_length = ~0ULL;
> +	fiemap->fm_extent_count = 1;
> +
> +	fiemap->fm_flags =  -1;
nit: fiemap->fm_flags = -1;

> +	TST_EXP_FAIL(ioctl(fd, FS_IOC_FIEMAP, fiemap), EBADR);
> +
> +	fiemap->fm_flags =  0;
> +	TST_EXP_PASS(ioctl(fd, FS_IOC_FIEMAP, fiemap));
> +	print_extens(fiemap);
> +	TST_EXP_EXPR(fiemap->fm_mapped_extents == 0,
> +		"Check extent fm_mapped_extents is 0");
> +
> +	char *buf = SAFE_MALLOC(blk_size);
> +
> +	SAFE_WRITE(SAFE_WRITE_ANY, fd, buf, blk_size);
> +	fiemap->fm_flags = FIEMAP_FLAG_SYNC;
> +	TST_EXP_PASS(ioctl(fd, FS_IOC_FIEMAP, fiemap));
> +	print_extens(fiemap);
> +	check_extent(fiemap, 1, 0, FIEMAP_EXTENT_LAST, 1, blk_size);
> +
> +	fiemap->fm_extent_count = NUM_EXTENT;
> +	SAFE_LSEEK(fd, 2 * blk_size, SEEK_SET);
> +	SAFE_WRITE(SAFE_WRITE_ALL, fd, buf, blk_size);
> +	SAFE_LSEEK(fd, 4 * blk_size, SEEK_SET);
> +	SAFE_WRITE(SAFE_WRITE_ALL, fd, buf, blk_size);
> +	TST_EXP_PASS(ioctl(fd, FS_IOC_FIEMAP, fiemap));
> +	print_extens(fiemap);
> +	check_extent(fiemap, NUM_EXTENT, NUM_EXTENT - 1, FIEMAP_EXTENT_LAST, 1, blk_size);
> +
> +	free(buf);
> +	free(fiemap);
> +	SAFE_CLOSE(fd);
> +	unlink(TESTFILE);

SAFE_UNLINK(TESTFILE);

> +}
> +
> +static struct tst_test test = {
> +	.mount_device = 1,
> +	.mntpoint = TMPDIR,
> +	.all_filesystems = 1,
> +	.skip_filesystems = (const char *const[]) {
> +		"exfat", "vfat", "fuse", "ntfs", "tmpfs", NULL

Why do you whitelist fuse? Which filesystem under fuse does not work?

> +	},
> +	.test_all = verify_ioctl,
> +	.needs_root = 1,
> +	.needs_tmpdir = 1,
needs_tmpdir is not needed (you use .all_filesystems). You would find that when
generating docparse.

Kind regards,
Petr

-- 
Mailing list info: https://lists.linux.it/listinfo/ltp

Re: [LTP] [PATCH v3] ioctl_fiemap01: New test for fiemap ioctl()

[Wei Gao via ltp]

On Wed, Apr 03, 2024 at 11:28:27AM +0200, Petr Vorel wrote:
> Hi Wei,
> 
> > +static struct tst_test test = {
> > +	.mount_device = 1,
> > +	.mntpoint = TMPDIR,
> > +	.all_filesystems = 1,
> > +	.skip_filesystems = (const char *const[]) {
> > +		"exfat", "vfat", "fuse", "ntfs", "tmpfs", NULL
> 
> Why do you whitelist fuse? Which filesystem under fuse does not work?
I will remove fuse in next patch.

But i find fs_type_whitelist not contain "fuse", so this will lead 
func tst_get_supported_fs_type can not handle "fuse" filesystem, 
means add/remove "fuse" into skip_filesystems will not take any effect. 
Correct me if i have any misunderstanding.

static const char *const fs_type_whitelist[] = {
        "ext2",
        "ext3",
        "ext4",
        "xfs",
        "btrfs",
        "bcachefs",
        "vfat",
        "exfat",
        "ntfs",
        "tmpfs",
        NULL
};


-- 
Mailing list info: https://lists.linux.it/listinfo/ltp

Re: [LTP] [PATCH v3] ioctl_fiemap01: New test for fiemap ioctl()

[Petr Vorel]

> On Wed, Apr 03, 2024 at 11:28:27AM +0200, Petr Vorel wrote:
> > Hi Wei,

> > > +static struct tst_test test = {
> > > +	.mount_device = 1,
> > > +	.mntpoint = TMPDIR,
> > > +	.all_filesystems = 1,
> > > +	.skip_filesystems = (const char *const[]) {
> > > +		"exfat", "vfat", "fuse", "ntfs", "tmpfs", NULL

> > Why do you whitelist fuse? Which filesystem under fuse does not work?
> I will remove fuse in next patch.

> But i find fs_type_whitelist not contain "fuse", so this will lead 

lib/tst_supported_fs_types.c contains:

skip_fuse = tst_fs_in_skiplist("fuse", skiplist);

=> please use it.

Kind regards,
Petr

> func tst_get_supported_fs_type can not handle "fuse" filesystem, 
> means add/remove "fuse" into skip_filesystems will not take any effect. 
> Correct me if i have any misunderstanding.

> static const char *const fs_type_whitelist[] = {
>         "ext2",
>         "ext3",
>         "ext4",
>         "xfs",
>         "btrfs",
>         "bcachefs",
>         "vfat",
>         "exfat",
>         "ntfs",
>         "tmpfs",
>         NULL
> };


-- 
Mailing list info: https://lists.linux.it/listinfo/ltp

[LTP] [PATCH v4] ioctl_fiemap01: New test for fiemap ioctl()

[Wei Gao via ltp]

Fixes: #535

Signed-off-by: Wei Gao <wegao@suse.com>
---
 runtest/syscalls                              |   2 +
 testcases/kernel/syscalls/ioctl/.gitignore    |   1 +
 .../kernel/syscalls/ioctl/ioctl_fiemap01.c    | 110 ++++++++++++++++++
 3 files changed, 113 insertions(+)
 create mode 100644 testcases/kernel/syscalls/ioctl/ioctl_fiemap01.c

diff --git a/runtest/syscalls b/runtest/syscalls
index 6e2407879..4e6ce5aef 100644
--- a/runtest/syscalls
+++ b/runtest/syscalls
@@ -589,6 +589,8 @@ ioctl_ns07 ioctl_ns07
 
 ioctl_sg01 ioctl_sg01
 
+ioctl_fiemap01 ioctl_fiemap01
+
 inotify_init1_01 inotify_init1_01
 inotify_init1_02 inotify_init1_02
 
diff --git a/testcases/kernel/syscalls/ioctl/.gitignore b/testcases/kernel/syscalls/ioctl/.gitignore
index 5fff7a61d..64adcdfe6 100644
--- a/testcases/kernel/syscalls/ioctl/.gitignore
+++ b/testcases/kernel/syscalls/ioctl/.gitignore
@@ -22,3 +22,4 @@
 /ioctl_ns06
 /ioctl_ns07
 /ioctl_sg01
+/ioctl_fiemap01
diff --git a/testcases/kernel/syscalls/ioctl/ioctl_fiemap01.c b/testcases/kernel/syscalls/ioctl/ioctl_fiemap01.c
new file mode 100644
index 000000000..1b3f80ed9
--- /dev/null
+++ b/testcases/kernel/syscalls/ioctl/ioctl_fiemap01.c
@@ -0,0 +1,110 @@
+// SPDX-License-Identifier: GPL-2.0-only
+/*
+ * Copyright (c) 2023 Wei Gao <wegao@suse.com>
+ */
+
+/*\
+ * [Description]
+ *
+ * Verify basic fiemap ioctl.
+ */
+
+#include <linux/fs.h>
+#include <linux/fiemap.h>
+#include <stdlib.h>
+#include <sys/statvfs.h>
+
+#include "tst_test.h"
+
+#define MNTPOINT "mntpoint"
+#define TESTFILE "testfile"
+#define NUM_EXTENT 3
+
+static void print_extens(struct fiemap *fiemap)
+{
+	tst_res(TDEBUG, "File extent count: %u", fiemap->fm_mapped_extents);
+
+	for (unsigned int i = 0; i < fiemap->fm_mapped_extents; ++i) {
+		tst_res(TDEBUG, "Extent %u: Logical offset: %llu, Physical offset: %llu, flags: %u, Length: %llu",
+				i + 1,
+				fiemap->fm_extents[i].fe_logical,
+				fiemap->fm_extents[i].fe_physical,
+				fiemap->fm_extents[i].fe_flags,
+				fiemap->fm_extents[i].fe_length);
+	}
+}
+
+static void check_extent(struct fiemap *fiemap, unsigned int fm_mapped_extents, int index_extents, int fe_flags, unsigned int min_fe_physical, unsigned int fe_length)
+{
+	TST_EXP_EXPR(fiemap->fm_mapped_extents == fm_mapped_extents,
+		"Check extent fm_mapped_extents is %d", fm_mapped_extents);
+	TST_EXP_EXPR(fiemap->fm_extents[index_extents].fe_flags & fe_flags,
+		"Check fe_flags is %d", fe_flags);
+	TST_EXP_EXPR(fiemap->fm_extents[index_extents].fe_physical >= min_fe_physical,
+		"Check fe_physical > %d", min_fe_physical);
+	TST_EXP_EXPR(fiemap->fm_extents[index_extents].fe_length == fe_length,
+		"Check fe_length is %d", fe_length);
+}
+
+static void verify_ioctl(void)
+{
+	int fd;
+	struct fiemap *fiemap;
+	struct statvfs fs_info;
+	unsigned long blk_size;
+
+	SAFE_CHDIR(MNTPOINT);
+	fd = SAFE_OPEN(TESTFILE, O_RDWR | O_CREAT, 0644);
+
+	if (statvfs(".", &fs_info) != 0)
+		tst_brk(TBROK, "statvfs failed");
+
+	blk_size = fs_info.f_bsize;
+
+	fiemap = SAFE_MALLOC(sizeof(struct fiemap) + sizeof(struct fiemap_extent) * NUM_EXTENT);
+	fiemap->fm_start = 0;
+	fiemap->fm_length = ~0ULL;
+	fiemap->fm_extent_count = 1;
+
+	fiemap->fm_flags = -1;
+	TST_EXP_FAIL(ioctl(fd, FS_IOC_FIEMAP, fiemap), EBADR);
+
+	fiemap->fm_flags =  0;
+	TST_EXP_PASS(ioctl(fd, FS_IOC_FIEMAP, fiemap));
+	print_extens(fiemap);
+	TST_EXP_EXPR(fiemap->fm_mapped_extents == 0,
+		"Check extent fm_mapped_extents is 0");
+
+	char *buf = SAFE_MALLOC(blk_size);
+
+	SAFE_WRITE(SAFE_WRITE_ANY, fd, buf, blk_size);
+	fiemap->fm_flags = FIEMAP_FLAG_SYNC;
+	TST_EXP_PASS(ioctl(fd, FS_IOC_FIEMAP, fiemap));
+	print_extens(fiemap);
+	check_extent(fiemap, 1, 0, FIEMAP_EXTENT_LAST, 1, blk_size);
+
+	fiemap->fm_extent_count = NUM_EXTENT;
+	SAFE_LSEEK(fd, 2 * blk_size, SEEK_SET);
+	SAFE_WRITE(SAFE_WRITE_ALL, fd, buf, blk_size);
+	SAFE_LSEEK(fd, 4 * blk_size, SEEK_SET);
+	SAFE_WRITE(SAFE_WRITE_ALL, fd, buf, blk_size);
+	TST_EXP_PASS(ioctl(fd, FS_IOC_FIEMAP, fiemap));
+	print_extens(fiemap);
+	check_extent(fiemap, NUM_EXTENT, NUM_EXTENT - 1, FIEMAP_EXTENT_LAST, 1, blk_size);
+
+	free(buf);
+	free(fiemap);
+	SAFE_CLOSE(fd);
+	SAFE_UNLINK(TESTFILE);
+}
+
+static struct tst_test test = {
+	.mount_device = 1,
+	.mntpoint = MNTPOINT,
+	.all_filesystems = 1,
+	.skip_filesystems = (const char *const[]) {
+		"exfat", "vfat", "ntfs", "tmpfs", NULL
+	},
+	.test_all = verify_ioctl,
+	.needs_root = 1,
+};
-- 
2.35.3


-- 
Mailing list info: https://lists.linux.it/listinfo/ltp

Re: [LTP] [PATCH v4] ioctl_fiemap01: New test for fiemap ioctl()

[Cyril Hrubis]

Hi!
> +/*\
> + * [Description]
> + *
> + * Verify basic fiemap ioctl.

This should explain better what the test actually does.

We are doing several things here, that should be described including
checks for invalid flags, empty file, and then finally check that we get
sane data extend data from the call in two different situations. These
subtests should be described here.

> + */
> +
> +#include <linux/fs.h>
> +#include <linux/fiemap.h>
> +#include <stdlib.h>
> +#include <sys/statvfs.h>
> +
> +#include "tst_test.h"
> +
> +#define MNTPOINT "mntpoint"
> +#define TESTFILE "testfile"
> +#define NUM_EXTENT 3
> +
> +static void print_extens(struct fiemap *fiemap)
> +{
> +	tst_res(TDEBUG, "File extent count: %u", fiemap->fm_mapped_extents);
> +
> +	for (unsigned int i = 0; i < fiemap->fm_mapped_extents; ++i) {
> +		tst_res(TDEBUG, "Extent %u: Logical offset: %llu, Physical offset: %llu, flags: %u, Length: %llu",
> +				i + 1,
> +				fiemap->fm_extents[i].fe_logical,
> +				fiemap->fm_extents[i].fe_physical,
> +				fiemap->fm_extents[i].fe_flags,
> +				fiemap->fm_extents[i].fe_length);
> +	}
> +}
> +
> +static void check_extent(struct fiemap *fiemap, unsigned int fm_mapped_extents, int index_extents, int fe_flags, unsigned int min_fe_physical, unsigned int fe_length)

Didn't make check complain that this line is too long?

> +{
> +	TST_EXP_EXPR(fiemap->fm_mapped_extents == fm_mapped_extents,
> +		"Check extent fm_mapped_extents is %d", fm_mapped_extents);
> +	TST_EXP_EXPR(fiemap->fm_extents[index_extents].fe_flags & fe_flags,
> +		"Check fe_flags is %d", fe_flags);
> +	TST_EXP_EXPR(fiemap->fm_extents[index_extents].fe_physical >= min_fe_physical,
> +		"Check fe_physical > %d", min_fe_physical);
> +	TST_EXP_EXPR(fiemap->fm_extents[index_extents].fe_length == fe_length,
> +		"Check fe_length is %d", fe_length);
> +}
> +
> +static void verify_ioctl(void)
> +{
> +	int fd;
> +	struct fiemap *fiemap;
> +	struct statvfs fs_info;
> +	unsigned long blk_size;
> +
> +	SAFE_CHDIR(MNTPOINT);
> +	fd = SAFE_OPEN(TESTFILE, O_RDWR | O_CREAT, 0644);
> +
> +	if (statvfs(".", &fs_info) != 0)
> +		tst_brk(TBROK, "statvfs failed");

It would be nicer if we added SAFE_STATVFS() in a separate patch and
then used it here.

> +	blk_size = fs_info.f_bsize;
> +
> +	fiemap = SAFE_MALLOC(sizeof(struct fiemap) + sizeof(struct fiemap_extent) * NUM_EXTENT);
> +	fiemap->fm_start = 0;
> +	fiemap->fm_length = ~0ULL;
> +	fiemap->fm_extent_count = 1;
> +
> +	fiemap->fm_flags = -1;
> +	TST_EXP_FAIL(ioctl(fd, FS_IOC_FIEMAP, fiemap), EBADR);
> +
> +	fiemap->fm_flags =  0;
> +	TST_EXP_PASS(ioctl(fd, FS_IOC_FIEMAP, fiemap));
> +	print_extens(fiemap);
> +	TST_EXP_EXPR(fiemap->fm_mapped_extents == 0,
> +		"Check extent fm_mapped_extents is 0");
                   ^
		   Maybe better "Empty file should have 0 extends mapped"

Or something that actually explains better why it should be 0.

> +	char *buf = SAFE_MALLOC(blk_size);
> +
> +	SAFE_WRITE(SAFE_WRITE_ANY, fd, buf, blk_size);
> +	fiemap->fm_flags = FIEMAP_FLAG_SYNC;
> +	TST_EXP_PASS(ioctl(fd, FS_IOC_FIEMAP, fiemap));
> +	print_extens(fiemap);
> +	check_extent(fiemap, 1, 0, FIEMAP_EXTENT_LAST, 1, blk_size);
> +
> +	fiemap->fm_extent_count = NUM_EXTENT;
> +	SAFE_LSEEK(fd, 2 * blk_size, SEEK_SET);
> +	SAFE_WRITE(SAFE_WRITE_ALL, fd, buf, blk_size);
> +	SAFE_LSEEK(fd, 4 * blk_size, SEEK_SET);
> +	SAFE_WRITE(SAFE_WRITE_ALL, fd, buf, blk_size);
> +	TST_EXP_PASS(ioctl(fd, FS_IOC_FIEMAP, fiemap));
> +	print_extens(fiemap);
> +	check_extent(fiemap, NUM_EXTENT, NUM_EXTENT - 1, FIEMAP_EXTENT_LAST, 1, blk_size);
> +
> +	free(buf);
> +	free(fiemap);
> +	SAFE_CLOSE(fd);
> +	SAFE_UNLINK(TESTFILE);
> +}
> +
> +static struct tst_test test = {
> +	.mount_device = 1,
> +	.mntpoint = MNTPOINT,
> +	.all_filesystems = 1,
> +	.skip_filesystems = (const char *const[]) {
> +		"exfat", "vfat", "ntfs", "tmpfs", NULL
> +	},
> +	.test_all = verify_ioctl,
> +	.needs_root = 1,
> +};
> -- 
> 2.35.3
> 
> 
> -- 
> Mailing list info: https://lists.linux.it/listinfo/ltp

-- 
Cyril Hrubis
chrubis@suse.cz

-- 
Mailing list info: https://lists.linux.it/listinfo/ltp

[LTP] [PATCH v5 0/2] ioctl_fiemap01: New test for fiemap ioctl()

[Wei Gao via ltp]

Wei Gao (2):
  tst_safe_macros.h: Add SAFE_STATVFS
  ioctl_fiemap01: New test for fiemap ioctl()

 include/tst_safe_macros.h                     |  21 +++
 runtest/syscalls                              |   2 +
 testcases/kernel/syscalls/ioctl/.gitignore    |   1 +
 .../kernel/syscalls/ioctl/ioctl_fiemap01.c    | 122 ++++++++++++++++++
 4 files changed, 146 insertions(+)
 create mode 100644 testcases/kernel/syscalls/ioctl/ioctl_fiemap01.c

-- 
2.35.3


-- 
Mailing list info: https://lists.linux.it/listinfo/ltp

[LTP] [PATCH v5 1/2] tst_safe_macros.h: Add SAFE_STATVFS

[Wei Gao via ltp]

Signed-off-by: Wei Gao <wegao@suse.com>
---
 include/tst_safe_macros.h | 21 +++++++++++++++++++++
 1 file changed, 21 insertions(+)

diff --git a/include/tst_safe_macros.h b/include/tst_safe_macros.h
index f2ce8919b..777f81b5f 100644
--- a/include/tst_safe_macros.h
+++ b/include/tst_safe_macros.h
@@ -429,6 +429,27 @@ static inline int safe_statfs(const char *file, const int lineno,
 #define SAFE_STATFS(path, buf) \
 	safe_statfs(__FILE__, __LINE__, (path), (buf))
 
+static inline int safe_statvfs(const char *file, const int lineno,
+                              const char *path, struct statvfs *buf)
+{
+	int rval;
+
+	rval = statvfs(path, buf);
+
+	if (rval == -1) {
+		tst_brk_(file, lineno, TBROK | TERRNO,
+			"statvfs(%s,%p) failed", path, buf);
+	} else if (rval) {
+		tst_brk_(file, lineno, TBROK | TERRNO,
+			"Invalid statvfs(%s,%p) return value %d", path, buf,
+			rval);
+	}
+
+	return rval;
+}
+#define SAFE_STATVFS(path, buf) \
+	safe_statvfs(__FILE__, __LINE__, (path), (buf))
+
 static inline off_t safe_lseek(const char *file, const int lineno,
                                int fd, off_t offset, int whence)
 {
-- 
2.35.3


-- 
Mailing list info: https://lists.linux.it/listinfo/ltp

Re: [LTP] [PATCH v5 1/2] tst_safe_macros.h: Add SAFE_STATVFS

[Petr Vorel]

Hi Wei,

> +++ b/include/tst_safe_macros.h
> @@ -429,6 +429,27 @@ static inline int safe_statfs(const char *file, const int lineno,
>  #define SAFE_STATFS(path, buf) \
>  	safe_statfs(__FILE__, __LINE__, (path), (buf))

> +static inline int safe_statvfs(const char *file, const int lineno,
> +                              const char *path, struct statvfs *buf)
> +{
> +	int rval;
> +
> +	rval = statvfs(path, buf);
> +
> +	if (rval == -1) {
> +		tst_brk_(file, lineno, TBROK | TERRNO,
> +			"statvfs(%s,%p) failed", path, buf);
> +	} else if (rval) {
> +		tst_brk_(file, lineno, TBROK | TERRNO,
> +			"Invalid statvfs(%s,%p) return value %d", path, buf,
> +			rval);
> +	}

@Wei We usually add only function signature to headers, the rest goes into
lib/tst_safe_macros.c. The only exception are functions in
include/tst_safe_macros_inline.h due off_t or structs which contain it, which is
not this case.

Besides following ioctl_fiemap01.c it could be used also in libs/swap/libswap.c
and lib/tst_fill_fs.c, where we don't even check return code. Not that many
cases but probably useful.

FYI fstatvfs() with TBROK is used in fsync02.c not sure if to add it as well.

Kind regards,
Petr

-- 
Mailing list info: https://lists.linux.it/listinfo/ltp

Re: [LTP] [PATCH v5 1/2] tst_safe_macros.h: Add SAFE_STATVFS

[Wei Gao via ltp]

On Thu, Feb 27, 2025 at 05:27:17PM +0100, Petr Vorel wrote:
> Hi Wei,
> 
> > +++ b/include/tst_safe_macros.h
> > @@ -429,6 +429,27 @@ static inline int safe_statfs(const char *file, const int lineno,
> >  #define SAFE_STATFS(path, buf) \
> >  	safe_statfs(__FILE__, __LINE__, (path), (buf))
> 
> > +static inline int safe_statvfs(const char *file, const int lineno,
> > +                              const char *path, struct statvfs *buf)
> > +{
> > +	int rval;
> > +
> > +	rval = statvfs(path, buf);
> > +
> > +	if (rval == -1) {
> > +		tst_brk_(file, lineno, TBROK | TERRNO,
> > +			"statvfs(%s,%p) failed", path, buf);
> > +	} else if (rval) {
> > +		tst_brk_(file, lineno, TBROK | TERRNO,
> > +			"Invalid statvfs(%s,%p) return value %d", path, buf,
> > +			rval);
> > +	}
> 
> @Wei We usually add only function signature to headers, the rest goes into
> lib/tst_safe_macros.c. The only exception are functions in
> include/tst_safe_macros_inline.h due off_t or structs which contain it, which is
> not this case.
> 
> Besides following ioctl_fiemap01.c it could be used also in libs/swap/libswap.c
> and lib/tst_fill_fs.c, where we don't even check return code. Not that many
> cases but probably useful.
> 
> FYI fstatvfs() with TBROK is used in fsync02.c not sure if to add it as well.
Sure, i can take a look once above patch merged, thanks for your information.
> 
> Kind regards,
> Petr

-- 
Mailing list info: https://lists.linux.it/listinfo/ltp

[LTP] [PATCH v5 2/2] ioctl_fiemap01: New test for fiemap ioctl()

[Wei Gao via ltp]

Fixes: #535

Signed-off-by: Wei Gao <wegao@suse.com>
---
 runtest/syscalls                              |   2 +
 testcases/kernel/syscalls/ioctl/.gitignore    |   1 +
 .../kernel/syscalls/ioctl/ioctl_fiemap01.c    | 122 ++++++++++++++++++
 3 files changed, 125 insertions(+)
 create mode 100644 testcases/kernel/syscalls/ioctl/ioctl_fiemap01.c

diff --git a/runtest/syscalls b/runtest/syscalls
index 6e2407879..4e6ce5aef 100644
--- a/runtest/syscalls
+++ b/runtest/syscalls
@@ -589,6 +589,8 @@ ioctl_ns07 ioctl_ns07
 
 ioctl_sg01 ioctl_sg01
 
+ioctl_fiemap01 ioctl_fiemap01
+
 inotify_init1_01 inotify_init1_01
 inotify_init1_02 inotify_init1_02
 
diff --git a/testcases/kernel/syscalls/ioctl/.gitignore b/testcases/kernel/syscalls/ioctl/.gitignore
index 5fff7a61d..64adcdfe6 100644
--- a/testcases/kernel/syscalls/ioctl/.gitignore
+++ b/testcases/kernel/syscalls/ioctl/.gitignore
@@ -22,3 +22,4 @@
 /ioctl_ns06
 /ioctl_ns07
 /ioctl_sg01
+/ioctl_fiemap01
diff --git a/testcases/kernel/syscalls/ioctl/ioctl_fiemap01.c b/testcases/kernel/syscalls/ioctl/ioctl_fiemap01.c
new file mode 100644
index 000000000..61b3f1062
--- /dev/null
+++ b/testcases/kernel/syscalls/ioctl/ioctl_fiemap01.c
@@ -0,0 +1,122 @@
+// SPDX-License-Identifier: GPL-2.0-only
+/*
+ * Copyright (c) 2023 Wei Gao <wegao@suse.com>
+ */
+
+/*\
+ * [Description]
+ *
+ * Verify basic fiemap ioctl functionality, including:
+ * - The ioctl returns EBADR if it receives invalid fm_flags.
+ * - 0 extents are reported for an empty file.
+ * - The ioctl correctly retrieves single and multiple extent mappings after writing to the file.
+ */
+
+#include <linux/fs.h>
+#include <linux/fiemap.h>
+#include <stdlib.h>
+#include <sys/statvfs.h>
+
+#include "tst_test.h"
+
+#define MNTPOINT "mntpoint"
+#define TESTFILE "testfile"
+#define NUM_EXTENT 3
+
+static void print_extens(struct fiemap *fiemap)
+{
+	tst_res(TDEBUG, "File extent count: %u", fiemap->fm_mapped_extents);
+
+	for (unsigned int i = 0; i < fiemap->fm_mapped_extents; ++i) {
+		tst_res(TDEBUG, "Extent %u: Logical offset: %llu, Physical offset: %llu, flags: %u, Length: %llu",
+				i + 1,
+				fiemap->fm_extents[i].fe_logical,
+				fiemap->fm_extents[i].fe_physical,
+				fiemap->fm_extents[i].fe_flags,
+				fiemap->fm_extents[i].fe_length);
+	}
+}
+
+static void check_extent(struct fiemap *fiemap, unsigned int fm_mapped_extents,
+						int index_extents, int fe_flags,
+						unsigned int min_fe_physical,
+						unsigned int fe_length)
+{
+	TST_EXP_EXPR(fiemap->fm_mapped_extents == fm_mapped_extents,
+		"Check extent fm_mapped_extents is %d", fm_mapped_extents);
+	TST_EXP_EXPR(fiemap->fm_extents[index_extents].fe_flags & fe_flags,
+		"Check fe_flags is %d", fe_flags);
+	TST_EXP_EXPR(fiemap->fm_extents[index_extents].fe_physical >= min_fe_physical,
+		"Check fe_physical > %d", min_fe_physical);
+	TST_EXP_EXPR(fiemap->fm_extents[index_extents].fe_length == fe_length,
+		"Check fe_length is %d", fe_length);
+}
+
+static void verify_ioctl(void)
+{
+	int fd, ret;
+	struct fiemap *fiemap;
+	struct statvfs fs_info;
+	unsigned long blk_size;
+
+	SAFE_CHDIR(MNTPOINT);
+	fd = SAFE_OPEN(TESTFILE, O_RDWR | O_CREAT, 0644);
+
+	SAFE_STATVFS(".", &fs_info);
+
+	blk_size = fs_info.f_bsize;
+
+	fiemap = SAFE_MALLOC(sizeof(struct fiemap) + sizeof(struct fiemap_extent) * NUM_EXTENT);
+	fiemap->fm_start = 0;
+	fiemap->fm_length = ~0ULL;
+	fiemap->fm_extent_count = 1;
+	fiemap->fm_flags = FIEMAP_FLAG_XATTR;
+
+	ret = ioctl(fd, FS_IOC_FIEMAP, fiemap);
+	if (ret == -1) {
+		if (errno == ENOTTY)
+			tst_res(TCONF, "ioctl(FS_IOC_FIEMAP) not implemented");
+	}
+
+	fiemap->fm_flags = -1;
+	TST_EXP_FAIL(ioctl(fd, FS_IOC_FIEMAP, fiemap), EBADR);
+
+	fiemap->fm_flags =  0;
+	TST_EXP_PASS(ioctl(fd, FS_IOC_FIEMAP, fiemap));
+	print_extens(fiemap);
+	TST_EXP_EXPR(fiemap->fm_mapped_extents == 0,
+		"Empty file should have 0 extends mapped");
+
+	char *buf = SAFE_MALLOC(blk_size);
+
+	SAFE_WRITE(SAFE_WRITE_ANY, fd, buf, blk_size);
+	fiemap->fm_flags = FIEMAP_FLAG_SYNC;
+	TST_EXP_PASS(ioctl(fd, FS_IOC_FIEMAP, fiemap));
+	print_extens(fiemap);
+	check_extent(fiemap, 1, 0, FIEMAP_EXTENT_LAST, 1, blk_size);
+
+	fiemap->fm_extent_count = NUM_EXTENT;
+	SAFE_LSEEK(fd, 2 * blk_size, SEEK_SET);
+	SAFE_WRITE(SAFE_WRITE_ALL, fd, buf, blk_size);
+	SAFE_LSEEK(fd, 4 * blk_size, SEEK_SET);
+	SAFE_WRITE(SAFE_WRITE_ALL, fd, buf, blk_size);
+	TST_EXP_PASS(ioctl(fd, FS_IOC_FIEMAP, fiemap));
+	print_extens(fiemap);
+	check_extent(fiemap, NUM_EXTENT, NUM_EXTENT - 1, FIEMAP_EXTENT_LAST, 1, blk_size);
+
+	free(buf);
+	free(fiemap);
+	SAFE_CLOSE(fd);
+	SAFE_UNLINK(TESTFILE);
+}
+
+static struct tst_test test = {
+	.mount_device = 1,
+	.mntpoint = MNTPOINT,
+	.all_filesystems = 1,
+	.skip_filesystems = (const char *const[]) {
+		"exfat", "vfat", "ntfs", "tmpfs", NULL
+	},
+	.test_all = verify_ioctl,
+	.needs_root = 1,
+};
-- 
2.35.3


-- 
Mailing list info: https://lists.linux.it/listinfo/ltp

Re: [LTP] [PATCH v5 2/2] ioctl_fiemap01: New test for fiemap ioctl()

[Petr Vorel]

Hi Wei,

...
> +++ b/testcases/kernel/syscalls/ioctl/ioctl_fiemap01.c
> @@ -0,0 +1,122 @@
> +// SPDX-License-Identifier: GPL-2.0-only
Please GPL-2.0-or-later.

> +/*
> + * Copyright (c) 2023 Wei Gao <wegao@suse.com>
> + */
> +
> +/*\
> + * [Description]
Please remove this [Description].
> + *
> + * Verify basic fiemap ioctl functionality, including:
There needs to be an empty line. NOTE: if you add list (numbered or not) blank
line is required otherwise it's everything inline. If you build the docs you
would see it yourself.

> + * - The ioctl returns EBADR if it receives invalid fm_flags.
> + * - 0 extents are reported for an empty file.
> + * - The ioctl correctly retrieves single and multiple extent mappings after writing to the file.
> + */
> +
> +#include <linux/fs.h>
I suppose we need <linux/fs.h>

> +#include <linux/fiemap.h>
> +#include <stdlib.h>
> +#include <sys/statvfs.h>
> +
> +#include "tst_test.h"
> +
> +#define MNTPOINT "mntpoint"
> +#define TESTFILE "testfile"
> +#define NUM_EXTENT 3
> +
> +static void print_extens(struct fiemap *fiemap)
> +{
> +	tst_res(TDEBUG, "File extent count: %u", fiemap->fm_mapped_extents);
> +
> +	for (unsigned int i = 0; i < fiemap->fm_mapped_extents; ++i) {
> +		tst_res(TDEBUG, "Extent %u: Logical offset: %llu, Physical offset: %llu, flags: %u, Length: %llu",
> +				i + 1,
> +				fiemap->fm_extents[i].fe_logical,
> +				fiemap->fm_extents[i].fe_physical,
> +				fiemap->fm_extents[i].fe_flags,
> +				fiemap->fm_extents[i].fe_length);
> +	}
> +}
> +
> +static void check_extent(struct fiemap *fiemap, unsigned int fm_mapped_extents,
> +						int index_extents, int fe_flags,
> +						unsigned int min_fe_physical,
> +						unsigned int fe_length)
> +{
> +	TST_EXP_EXPR(fiemap->fm_mapped_extents == fm_mapped_extents,
> +		"Check extent fm_mapped_extents is %d", fm_mapped_extents);
> +	TST_EXP_EXPR(fiemap->fm_extents[index_extents].fe_flags & fe_flags,
> +		"Check fe_flags is %d", fe_flags);
> +	TST_EXP_EXPR(fiemap->fm_extents[index_extents].fe_physical >= min_fe_physical,
> +		"Check fe_physical > %d", min_fe_physical);
> +	TST_EXP_EXPR(fiemap->fm_extents[index_extents].fe_length == fe_length,
> +		"Check fe_length is %d", fe_length);
> +}
> +
> +static void verify_ioctl(void)
> +{
> +	int fd, ret;
> +	struct fiemap *fiemap;
> +	struct statvfs fs_info;
> +	unsigned long blk_size;
> +
> +	SAFE_CHDIR(MNTPOINT);
IMHO this will not work with -i2, it should be in the setup().

> +	fd = SAFE_OPEN(TESTFILE, O_RDWR | O_CREAT, 0644);
> +
> +	SAFE_STATVFS(".", &fs_info);

And probably these two as well.

> +
> +	blk_size = fs_info.f_bsize;
> +
> +	fiemap = SAFE_MALLOC(sizeof(struct fiemap) + sizeof(struct fiemap_extent) * NUM_EXTENT);
> +	fiemap->fm_start = 0;
> +	fiemap->fm_length = ~0ULL;
> +	fiemap->fm_extent_count = 1;
> +	fiemap->fm_flags = FIEMAP_FLAG_XATTR;
> +
> +	ret = ioctl(fd, FS_IOC_FIEMAP, fiemap);
> +	if (ret == -1) {
> +		if (errno == ENOTTY)
> +			tst_res(TCONF, "ioctl(FS_IOC_FIEMAP) not implemented");
I wonder if it's safe to put errno == ENOTTY check into SAFE_IOCTL().
We have similar checks in safe_socket() and other.

e.g.:
#define TTYPE (errno == ENOTTY ? TCONF : TBROK)

Maybe it's not safe, ENOTTY might be caused by some test error which deserves
TBROK:

       ENOTTY fd is not associated with a character special device.

       ENOTTY The specified operation does not apply to the kind of object that the file descriptor fd references.


If check used here here, it should be followed by tst_brk(), right?

> +	}
> +
> +	fiemap->fm_flags = -1;
> +	TST_EXP_FAIL(ioctl(fd, FS_IOC_FIEMAP, fiemap), EBADR);
> +
> +	fiemap->fm_flags =  0;
> +	TST_EXP_PASS(ioctl(fd, FS_IOC_FIEMAP, fiemap));
> +	print_extens(fiemap);
> +	TST_EXP_EXPR(fiemap->fm_mapped_extents == 0,
> +		"Empty file should have 0 extends mapped");
> +
> +	char *buf = SAFE_MALLOC(blk_size);
> +
> +	SAFE_WRITE(SAFE_WRITE_ANY, fd, buf, blk_size);
> +	fiemap->fm_flags = FIEMAP_FLAG_SYNC;
> +	TST_EXP_PASS(ioctl(fd, FS_IOC_FIEMAP, fiemap));
> +	print_extens(fiemap);
> +	check_extent(fiemap, 1, 0, FIEMAP_EXTENT_LAST, 1, blk_size);
> +
> +	fiemap->fm_extent_count = NUM_EXTENT;
> +	SAFE_LSEEK(fd, 2 * blk_size, SEEK_SET);
> +	SAFE_WRITE(SAFE_WRITE_ALL, fd, buf, blk_size);
> +	SAFE_LSEEK(fd, 4 * blk_size, SEEK_SET);
> +	SAFE_WRITE(SAFE_WRITE_ALL, fd, buf, blk_size);
> +	TST_EXP_PASS(ioctl(fd, FS_IOC_FIEMAP, fiemap));
> +	print_extens(fiemap);
> +	check_extent(fiemap, NUM_EXTENT, NUM_EXTENT - 1, FIEMAP_EXTENT_LAST, 1, blk_size);
> +
> +	free(buf);
> +	free(fiemap);
> +	SAFE_CLOSE(fd);
> +	SAFE_UNLINK(TESTFILE);
> +}
> +
> +static struct tst_test test = {
> +	.mount_device = 1,
> +	.mntpoint = MNTPOINT,
> +	.all_filesystems = 1,
> +	.skip_filesystems = (const char *const[]) {
> +		"exfat", "vfat", "ntfs", "tmpfs", NULL

Is the function unimplemented on these (even on tmpfs)? I would expect that but
better to explain in the commit message why it's skipped.

Kind regards,
Petr

-- 
Mailing list info: https://lists.linux.it/listinfo/ltp

Re: [LTP] [PATCH v5 2/2] ioctl_fiemap01: New test for fiemap ioctl()

[Wei Gao via ltp]

On Thu, Feb 27, 2025 at 05:43:38PM +0100, Petr Vorel wrote:
> Hi Wei,
> 
> ...
> 
> > +
> > +	ret = ioctl(fd, FS_IOC_FIEMAP, fiemap);
> > +	if (ret == -1) {
> > +		if (errno == ENOTTY)
> > +			tst_res(TCONF, "ioctl(FS_IOC_FIEMAP) not implemented");
> I wonder if it's safe to put errno == ENOTTY check into SAFE_IOCTL().
> We have similar checks in safe_socket() and other.
> 
> e.g.:
> #define TTYPE (errno == ENOTTY ? TCONF : TBROK)
> 
> Maybe it's not safe, ENOTTY might be caused by some test error which deserves
> TBROK:
> 
>        ENOTTY fd is not associated with a character special device.
> 
>        ENOTTY The specified operation does not apply to the kind of object that the file descriptor fd references.
> 
I remove this code in next version, i have done quick test on our old build such as 12-sp5 , result is pass

susetest:~ # cat /etc/os-release
NAME="SLES"
VERSION="12-SP5"
VERSION_ID="12.5"
PRETTY_NAME="SUSE Linux Enterprise Server 12 SP5"
ID="sles"
ANSI_COLOR="0;32"
CPE_NAME="cpe:/o:suse:sles:12:sp5"
susetest:~ # uname
uname    uname26
susetest:~ # uname -r
4.12.14-122.231-default

> > +
> > +static struct tst_test test = {
> > +	.mount_device = 1,
> > +	.mntpoint = MNTPOINT,
> > +	.all_filesystems = 1,
> > +	.skip_filesystems = (const char *const[]) {
> > +		"exfat", "vfat", "ntfs", "tmpfs", NULL
> 
> Is the function unimplemented on these (even on tmpfs)? I would expect that but
tmpfs is an in-memory filesystem and does not store any file into real disk, so it
not suppose to support it. 
> better to explain in the commit message why it's skipped.
I have done some check on other filesystems such as exfat/vfat/ntfs, it show unsupport
error, still need further investigation if we want figure out root cause, just for
safe reason i skip those filesystem in this case currently.


attach test log:
cat /etc/os-release
NAME="openSUSE Leap"
VERSION="15.5"
ID="opensuse-leap"
ID_LIKE="suse opensuse"
VERSION_ID="15.5"
PRETTY_NAME="openSUSE Leap 15.5"
ANSI_COLOR="0;32"
CPE_NAME="cpe:/o:opensuse:leap:15.5"
BUG_REPORT_URL="https://bugs.opensuse.org"
HOME_URL="https://www.opensuse.org/"
DOCUMENTATION_URL="https://en.opensuse.org/Portal:Leap"
LOGO="distributor-logo-Leap"


tst_kconfig.c:88: TINFO: Parsing kernel config '/proc/config.gz'
tst_kconfig.c:678: TINFO: CONFIG_FAULT_INJECTION kernel option detected which might slow the execution
tst_test.c:1724: TINFO: Overall timeout per run is 0h 02m 00s
tst_supported_fs_types.c:97: TINFO: Kernel supports ext2
tst_supported_fs_types.c:62: TINFO: mkfs.ext2 does exist
tst_supported_fs_types.c:97: TINFO: Kernel supports ext3
tst_supported_fs_types.c:62: TINFO: mkfs.ext3 does exist
tst_supported_fs_types.c:97: TINFO: Kernel supports ext4
tst_supported_fs_types.c:62: TINFO: mkfs.ext4 does exist
tst_supported_fs_types.c:97: TINFO: Kernel supports xfs
tst_supported_fs_types.c:62: TINFO: mkfs.xfs does exist
tst_supported_fs_types.c:97: TINFO: Kernel supports btrfs
tst_supported_fs_types.c:62: TINFO: mkfs.btrfs does exist
tst_supported_fs_types.c:105: TINFO: Skipping bcachefs because of FUSE blacklist
tst_supported_fs_types.c:170: TINFO: Skipping vfat as requested by the test
tst_supported_fs_types.c:170: TINFO: Skipping exfat as requested by the test
tst_supported_fs_types.c:132: TINFO: FUSE does support ntfs
tst_supported_fs_types.c:62: TINFO: mkfs.ntfs does exist
tst_supported_fs_types.c:97: TINFO: Kernel supports tmpfs
tst_supported_fs_types.c:49: TINFO: mkfs is not needed for tmpfs

tst_test.c:1833: TINFO: === Testing on vfat ===
tst_test.c:1170: TINFO: Formatting /dev/loop0 with vfat opts='' extra opts=''
tst_test.c:1183: TINFO: Mounting /dev/loop0 to /tmp/LTP_iocNjlayn/mntpoint fstyp=vfat flags=0
ioctl_fiemap01.c:87: TFAIL: ioctl(fd, FS_IOC_FIEMAP, fiemap) expected EBADR: EOPNOTSUPP (95)
ioctl_fiemap01.c:90: TFAIL: ioctl(fd, FS_IOC_FIEMAP, fiemap) failed: EOPNOTSUPP (95)
tst_test.c:1797: TBROK: Test killed by SIGSEGV!



tst_test.c:1833: TINFO: === Testing on exfat ===
tst_test.c:1170: TINFO: Formatting /dev/loop0 with exfat opts='' extra opts=''
tst_test.c:1183: TINFO: Mounting /dev/loop0 to /tmp/LTP_ioclNusF7/mntpoint fstyp=exfat flags=0
ioctl_fiemap01.c:87: TFAIL: ioctl(fd, FS_IOC_FIEMAP, fiemap) expected EBADR: EOPNOTSUPP (95)
ioctl_fiemap01.c:90: TFAIL: ioctl(fd, FS_IOC_FIEMAP, fiemap) failed: EOPNOTSUPP (95)
tst_test.c:1797: TBROK: Test killed by SIGSEGV!



tst_test.c:1833: TINFO: === Testing on ntfs ===
tst_test.c:1170: TINFO: Formatting /dev/loop0 with ntfs opts='' extra opts=''
The partition start sector was not specified for /dev/loop0 and it could not be obtained automatically.  It has been set to 0.
The number of sectors per track was not specified for /dev/loop0 and it could not be obtained automatically.  It has been set to 0.
The number of heads was not specified for /dev/loop0 and it could not be obtained automatically.  It has been set to 0.
To boot from a device, Windows needs the 'partition start sector', the 'sectors per track' and the 'number of heads' to be set.
Windows will not be able to boot from this device.
tst_test.c:1183: TINFO: Mounting /dev/loop0 to /tmp/LTP_iocGtgwCr/mntpoint fstyp=ntfs flags=0
tst_test.c:1183: TINFO: Trying FUSE...
ioctl_fiemap01.c:87: TFAIL: ioctl(fd, FS_IOC_FIEMAP, fiemap) expected EBADR: EOPNOTSUPP (95)
ioctl_fiemap01.c:90: TFAIL: ioctl(fd, FS_IOC_FIEMAP, fiemap) failed: EOPNOTSUPP (95)
tst_test.c:1797: TBROK: Test killed by SIGSEGV!



tst_test.c:1833: TINFO: === Testing on tmpfs ===
tst_test.c:1170: TINFO: Skipping mkfs for TMPFS filesystem
tst_test.c:1146: TINFO: Limiting tmpfs size to 32MB
tst_test.c:1183: TINFO: Mounting ltp-tmpfs to /tmp/LTP_iocUtSP0X/mntpoint fstyp=tmpfs flags=0
ioctl_fiemap01.c:87: TFAIL: ioctl(fd, FS_IOC_FIEMAP, fiemap) expected EBADR: EOPNOTSUPP (95)
ioctl_fiemap01.c:90: TFAIL: ioctl(fd, FS_IOC_FIEMAP, fiemap) failed: EOPNOTSUPP (95)
tst_test.c:1797: TBROK: Test killed by SIGSEGV!


> 
> Kind regards,
> Petr

-- 
Mailing list info: https://lists.linux.it/listinfo/ltp

[LTP] [PATCH v6 0/2] ioctl_fiemap01: New test for fiemap ioctl()

[Wei Gao via ltp]

Changes v5-v6:
* Remove ioctl support check
* Move implementation of safe_statvfs into tst_safe_macros.c
* Move SAFE_CHDIR to setup()
* Other small update base Petr's comments

link to v5:
https://patchwork.ozlabs.org/project/ltp/cover/20241212085058.29551-1-wegao@suse.com/

Wei Gao (2):
  tst_safe_macros.h: Add SAFE_STATVFS
  ioctl_fiemap01: New test for fiemap ioctl()

 include/tst_safe_macros.h                     |   6 +
 lib/tst_safe_macros.c                         |  19 +++
 runtest/syscalls                              |   1 +
 testcases/kernel/syscalls/ioctl/.gitignore    |   1 +
 .../kernel/syscalls/ioctl/ioctl_fiemap01.c    | 119 ++++++++++++++++++
 5 files changed, 146 insertions(+)
 create mode 100644 testcases/kernel/syscalls/ioctl/ioctl_fiemap01.c

-- 
2.35.3


-- 
Mailing list info: https://lists.linux.it/listinfo/ltp

[LTP] [PATCH v6 1/2] tst_safe_macros.h: Add SAFE_STATVFS

[Wei Gao via ltp]

Signed-off-by: Wei Gao <wegao@suse.com>
---
 include/tst_safe_macros.h |  6 ++++++
 lib/tst_safe_macros.c     | 19 +++++++++++++++++++
 2 files changed, 25 insertions(+)

diff --git a/include/tst_safe_macros.h b/include/tst_safe_macros.h
index 3b02f86c7..19504beb5 100644
--- a/include/tst_safe_macros.h
+++ b/include/tst_safe_macros.h
@@ -12,6 +12,7 @@
 #include <sys/time.h>
 #include <sys/resource.h>
 #include <sys/stat.h>
+#include <sys/statvfs.h>
 #include <sys/vfs.h>
 #include <sys/sysinfo.h>
 #include <sys/uio.h>
@@ -503,4 +504,9 @@ char *safe_ptsname(const char *const file, const int lineno, int masterfd);
 #define SAFE_PTSNAME(masterfd) \
 	safe_ptsname(__FILE__, __LINE__, (masterfd))
 
+int safe_statvfs(const char *file, const int lineno,
+                              const char *path, struct statvfs *buf);
+#define SAFE_STATVFS(path, buf) \
+	safe_statvfs(__FILE__, __LINE__, (path), (buf))
+
 #endif /* TST_SAFE_MACROS_H__ */
diff --git a/lib/tst_safe_macros.c b/lib/tst_safe_macros.c
index ba095a621..cdc8c7dd3 100644
--- a/lib/tst_safe_macros.c
+++ b/lib/tst_safe_macros.c
@@ -810,3 +810,22 @@ char *safe_ptsname(const char *const file, const int lineno, int masterfd)
 
 	return name;
 }
+
+int safe_statvfs(const char *file, const int lineno,
+                              const char *path, struct statvfs *buf)
+{
+	int rval;
+
+	rval = statvfs(path, buf);
+
+	if (rval == -1) {
+		tst_brk_(file, lineno, TBROK | TERRNO,
+			"statvfs(%s,%p) failed", path, buf);
+	} else if (rval) {
+		tst_brk_(file, lineno, TBROK | TERRNO,
+			"Invalid statvfs(%s,%p) return value %d", path, buf,
+			rval);
+	}
+
+	return rval;
+}
-- 
2.35.3


-- 
Mailing list info: https://lists.linux.it/listinfo/ltp

Re: [LTP] [PATCH v6 1/2] tst_safe_macros.h: Add SAFE_STATVFS

[Petr Vorel]

Hi Wei,

Reviewed-by: Petr Vorel <pvorel@suse.cz>
LGTM, thanks!

Kind regards,
Petr

-- 
Mailing list info: https://lists.linux.it/listinfo/ltp

[LTP] [PATCH v6 2/2] ioctl_fiemap01: New test for fiemap ioctl()

[Wei Gao via ltp]

Fixes: #535
Local test show EOPNOTSUPP on exfat/vfat/ntfs/tmpfs,
so descope related file system currently.

Signed-off-by: Wei Gao <wegao@suse.com>
---
 runtest/syscalls                              |   1 +
 testcases/kernel/syscalls/ioctl/.gitignore    |   1 +
 .../kernel/syscalls/ioctl/ioctl_fiemap01.c    | 119 ++++++++++++++++++
 3 files changed, 121 insertions(+)
 create mode 100644 testcases/kernel/syscalls/ioctl/ioctl_fiemap01.c

diff --git a/runtest/syscalls b/runtest/syscalls
index 77e3c942f..932b7030c 100644
--- a/runtest/syscalls
+++ b/runtest/syscalls
@@ -609,6 +609,7 @@ ioctl_ficlone02 ioctl_ficlone02
 ioctl_ficlone03 ioctl_ficlone03
 ioctl_ficlonerange01 ioctl_ficlonerange01
 ioctl_ficlonerange02 ioctl_ficlonerange02
+ioctl_fiemap01 ioctl_fiemap01
 
 inotify_init1_01 inotify_init1_01
 inotify_init1_02 inotify_init1_02
diff --git a/testcases/kernel/syscalls/ioctl/.gitignore b/testcases/kernel/syscalls/ioctl/.gitignore
index 1f099ff95..53a82bb57 100644
--- a/testcases/kernel/syscalls/ioctl/.gitignore
+++ b/testcases/kernel/syscalls/ioctl/.gitignore
@@ -28,3 +28,4 @@
 /ioctl_ficlone04
 /ioctl_ficlonerange01
 /ioctl_ficlonerange02
+/ioctl_fiemap01
diff --git a/testcases/kernel/syscalls/ioctl/ioctl_fiemap01.c b/testcases/kernel/syscalls/ioctl/ioctl_fiemap01.c
new file mode 100644
index 000000000..82f67adcf
--- /dev/null
+++ b/testcases/kernel/syscalls/ioctl/ioctl_fiemap01.c
@@ -0,0 +1,119 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+/*
+ * Copyright (c) 2023 Wei Gao <wegao@suse.com>
+ */
+
+/*\
+ * Verify basic fiemap ioctl functionality, including:
+ *
+ * - The ioctl returns EBADR if it receives invalid fm_flags.
+ * - 0 extents are reported for an empty file.
+ * - The ioctl correctly retrieves single and multiple extent mappings after writing to the file.
+ */
+
+#include <linux/fs.h>
+#include <linux/fiemap.h>
+#include <stdlib.h>
+#include <sys/statvfs.h>
+
+#include "tst_test.h"
+
+#define MNTPOINT "mntpoint"
+#define TESTFILE "testfile"
+#define NUM_EXTENT 3
+
+static void print_extens(struct fiemap *fiemap)
+{
+	tst_res(TDEBUG, "File extent count: %u", fiemap->fm_mapped_extents);
+
+	for (unsigned int i = 0; i < fiemap->fm_mapped_extents; ++i) {
+		tst_res(TDEBUG, "Extent %u: Logical offset: %llu, Physical offset: %llu, flags: %u, Length: %llu",
+				i + 1,
+				fiemap->fm_extents[i].fe_logical,
+				fiemap->fm_extents[i].fe_physical,
+				fiemap->fm_extents[i].fe_flags,
+				fiemap->fm_extents[i].fe_length);
+	}
+}
+
+static void check_extent(struct fiemap *fiemap, unsigned int fm_mapped_extents,
+						int index_extents, int fe_flags,
+						unsigned int min_fe_physical,
+						unsigned int fe_length)
+{
+	TST_EXP_EXPR(fiemap->fm_mapped_extents == fm_mapped_extents,
+		"Check extent fm_mapped_extents is %d", fm_mapped_extents);
+	TST_EXP_EXPR(fiemap->fm_extents[index_extents].fe_flags & fe_flags,
+		"Check fe_flags is %d", fe_flags);
+	TST_EXP_EXPR(fiemap->fm_extents[index_extents].fe_physical >= min_fe_physical,
+		"Check fe_physical > %d", min_fe_physical);
+	TST_EXP_EXPR(fiemap->fm_extents[index_extents].fe_length == fe_length,
+		"Check fe_length is %d", fe_length);
+}
+
+static void verify_ioctl(void)
+{
+	int fd;
+	struct fiemap *fiemap;
+	struct statvfs fs_info;
+	unsigned long blk_size;
+
+	fd = SAFE_OPEN(TESTFILE, O_RDWR | O_CREAT, 0644);
+
+	SAFE_STATVFS(".", &fs_info);
+
+	blk_size = fs_info.f_bsize;
+
+	fiemap = SAFE_MALLOC(sizeof(struct fiemap) + sizeof(struct fiemap_extent) * NUM_EXTENT);
+	fiemap->fm_start = 0;
+	fiemap->fm_length = ~0ULL;
+	fiemap->fm_extent_count = 1;
+
+	fiemap->fm_flags = -1;
+	TST_EXP_FAIL(ioctl(fd, FS_IOC_FIEMAP, fiemap), EBADR);
+
+	fiemap->fm_flags =  0;
+	TST_EXP_PASS(ioctl(fd, FS_IOC_FIEMAP, fiemap));
+	print_extens(fiemap);
+	TST_EXP_EXPR(fiemap->fm_mapped_extents == 0,
+		"Empty file should have 0 extends mapped");
+
+	char *buf = SAFE_MALLOC(blk_size);
+
+	SAFE_WRITE(SAFE_WRITE_ANY, fd, buf, blk_size);
+	fiemap->fm_flags = FIEMAP_FLAG_SYNC;
+	TST_EXP_PASS(ioctl(fd, FS_IOC_FIEMAP, fiemap));
+	print_extens(fiemap);
+	check_extent(fiemap, 1, 0, FIEMAP_EXTENT_LAST, 1, blk_size);
+
+	fiemap->fm_extent_count = NUM_EXTENT;
+	SAFE_LSEEK(fd, 2 * blk_size, SEEK_SET);
+	SAFE_WRITE(SAFE_WRITE_ALL, fd, buf, blk_size);
+	SAFE_LSEEK(fd, 4 * blk_size, SEEK_SET);
+	SAFE_WRITE(SAFE_WRITE_ALL, fd, buf, blk_size);
+	TST_EXP_PASS(ioctl(fd, FS_IOC_FIEMAP, fiemap));
+	print_extens(fiemap);
+	check_extent(fiemap, NUM_EXTENT, NUM_EXTENT - 1, FIEMAP_EXTENT_LAST, 1, blk_size);
+
+	free(buf);
+	free(fiemap);
+	SAFE_CLOSE(fd);
+	SAFE_UNLINK(TESTFILE);
+}
+
+static void setup(void)
+{
+	SAFE_CHDIR(MNTPOINT);
+}
+
+static struct tst_test test = {
+	.setup = setup,
+	.mount_device = 1,
+	.mntpoint = MNTPOINT,
+	.all_filesystems = 1,
+	.skip_filesystems = (const char *const[]) {
+		"exfat", "vfat", "fuse", "ntfs", "tmpfs", NULL
+	},
+	.test_all = verify_ioctl,
+	.needs_root = 1,
+};
-- 
2.35.3


-- 
Mailing list info: https://lists.linux.it/listinfo/ltp

Re: [LTP] [PATCH v6 2/2] ioctl_fiemap01: New test for fiemap ioctl()

[Cyril Hrubis]

Hi!
> diff --git a/testcases/kernel/syscalls/ioctl/ioctl_fiemap01.c b/testcases/kernel/syscalls/ioctl/ioctl_fiemap01.c
> new file mode 100644
> index 000000000..82f67adcf
> --- /dev/null
> +++ b/testcases/kernel/syscalls/ioctl/ioctl_fiemap01.c
> @@ -0,0 +1,119 @@
> +// SPDX-License-Identifier: GPL-2.0-or-later
> +/*
> + * Copyright (c) 2023 Wei Gao <wegao@suse.com>
> + */
> +
> +/*\
> + * Verify basic fiemap ioctl functionality, including:
> + *
> + * - The ioctl returns EBADR if it receives invalid fm_flags.
> + * - 0 extents are reported for an empty file.
> + * - The ioctl correctly retrieves single and multiple extent mappings after writing to the file.
> + */
> +
> +#include <linux/fs.h>
> +#include <linux/fiemap.h>
> +#include <stdlib.h>
> +#include <sys/statvfs.h>
> +
> +#include "tst_test.h"
> +
> +#define MNTPOINT "mntpoint"
> +#define TESTFILE "testfile"
> +#define NUM_EXTENT 3
> +
> +static void print_extens(struct fiemap *fiemap)
> +{
> +	tst_res(TDEBUG, "File extent count: %u", fiemap->fm_mapped_extents);
> +
> +	for (unsigned int i = 0; i < fiemap->fm_mapped_extents; ++i) {
> +		tst_res(TDEBUG, "Extent %u: Logical offset: %llu, Physical offset: %llu, flags: %u, Length: %llu",
> +				i + 1,
> +				fiemap->fm_extents[i].fe_logical,
> +				fiemap->fm_extents[i].fe_physical,
> +				fiemap->fm_extents[i].fe_flags,
> +				fiemap->fm_extents[i].fe_length);
> +	}
> +}
> +
> +static void check_extent(struct fiemap *fiemap, unsigned int fm_mapped_extents,
> +						int index_extents, int fe_flags,
> +						unsigned int min_fe_physical,

There is no point in passing the value of min_fe_physical if we just
pass 1 in all cases, we can just hardcode the value in the function.

> +						unsigned int fe_length)
> +{
> +	TST_EXP_EXPR(fiemap->fm_mapped_extents == fm_mapped_extents,
> +		"Check extent fm_mapped_extents is %d", fm_mapped_extents);

This check should be done in a separate function instead, because we
want to check all three extents in the last test and there is no point
in checking this three times.

Also we do have TST_EXP_EQ_UI() which should be used in the cases we are
testing for equality.

> +	TST_EXP_EXPR(fiemap->fm_extents[index_extents].fe_flags & fe_flags,
                                                                ^
This does not really work if we want to assert if the last flag was set
only on the last.

I.e. if for the last test we do:

	check_extent(fiemap, NUM_EXTENT, 0, 0, blk_size);
        check_extent(fiemap, NUM_EXTENT, 1, 0, blk_size);
        check_extent(fiemap, NUM_EXTENT, 2, FIEMAP_EXTENT_LAST, blk_size);

The fe_flags test fails because we get zero. What we have to do instead
is to pass the mask and the value and check for equality as:

	TST_EXP_EQ_UI((fiemap->fm_extents[index_extents].fe_flags & fe_mask) == fe_flags);

And then we call it like:

	check_extent(fiemap, NUM_EXTENT, 0, FIEMAP_EXTENT_LAST, 0, blk_size);
        check_extent(fiemap, NUM_EXTENT, 1, FIEMAP_EXTENT_LAST, 0, blk_size);
        check_extent(fiemap, NUM_EXTENT, 2, FIEMAP_EXTENT_LAST, FIEMAP_EXTENT_LAST, blk_size);

> +		"Check fe_flags is %d", fe_flags);
> +	TST_EXP_EXPR(fiemap->fm_extents[index_extents].fe_physical >= min_fe_physical,
> +		"Check fe_physical > %d", min_fe_physical);
> +	TST_EXP_EXPR(fiemap->fm_extents[index_extents].fe_length == fe_length,
                        ^
			And lastly but not least it would be shorter to
			get the pointer to the extent and the start as:

struct fiemap_extent *extent = &fieamp->fm_extents[index_extents];

And then do just extent->fe_foo in all cases.

> +		"Check fe_length is %d", fe_length);
> +}
> +
> +static void verify_ioctl(void)
> +{
> +	int fd;
> +	struct fiemap *fiemap;
> +	struct statvfs fs_info;
> +	unsigned long blk_size;
> +
> +	fd = SAFE_OPEN(TESTFILE, O_RDWR | O_CREAT, 0644);
> +
> +	SAFE_STATVFS(".", &fs_info);
> +
> +	blk_size = fs_info.f_bsize;
> +
> +	fiemap = SAFE_MALLOC(sizeof(struct fiemap) + sizeof(struct fiemap_extent) * NUM_EXTENT);
> +	fiemap->fm_start = 0;
> +	fiemap->fm_length = ~0ULL;
> +	fiemap->fm_extent_count = 1;
> +
> +	fiemap->fm_flags = -1;
> +	TST_EXP_FAIL(ioctl(fd, FS_IOC_FIEMAP, fiemap), EBADR);
> +
> +	fiemap->fm_flags =  0;
> +	TST_EXP_PASS(ioctl(fd, FS_IOC_FIEMAP, fiemap));
> +	print_extens(fiemap);
> +	TST_EXP_EXPR(fiemap->fm_mapped_extents == 0,
> +		"Empty file should have 0 extends mapped");
                                             ^
					  extents
> +
> +	char *buf = SAFE_MALLOC(blk_size);
> +
> +	SAFE_WRITE(SAFE_WRITE_ANY, fd, buf, blk_size);
> +	fiemap->fm_flags = FIEMAP_FLAG_SYNC;
> +	TST_EXP_PASS(ioctl(fd, FS_IOC_FIEMAP, fiemap));
> +	print_extens(fiemap);
> +	check_extent(fiemap, 1, 0, FIEMAP_EXTENT_LAST, 1, blk_size);
> +
> +	fiemap->fm_extent_count = NUM_EXTENT;
> +	SAFE_LSEEK(fd, 2 * blk_size, SEEK_SET);
> +	SAFE_WRITE(SAFE_WRITE_ALL, fd, buf, blk_size);
> +	SAFE_LSEEK(fd, 4 * blk_size, SEEK_SET);
> +	SAFE_WRITE(SAFE_WRITE_ALL, fd, buf, blk_size);
> +	TST_EXP_PASS(ioctl(fd, FS_IOC_FIEMAP, fiemap));
> +	print_extens(fiemap);
> +	check_extent(fiemap, NUM_EXTENT, NUM_EXTENT - 1, FIEMAP_EXTENT_LAST, 1, blk_size);
> +
> +	free(buf);
> +	free(fiemap);
> +	SAFE_CLOSE(fd);
> +	SAFE_UNLINK(TESTFILE);
> +}
> +
> +static void setup(void)
> +{
> +	SAFE_CHDIR(MNTPOINT);
> +}
> +
> +static struct tst_test test = {
> +	.setup = setup,
> +	.mount_device = 1,
> +	.mntpoint = MNTPOINT,
> +	.all_filesystems = 1,
> +	.skip_filesystems = (const char *const[]) {
> +		"exfat", "vfat", "fuse", "ntfs", "tmpfs", NULL
> +	},
> +	.test_all = verify_ioctl,
> +	.needs_root = 1,
> +};
> -- 
> 2.35.3
> 

-- 
Cyril Hrubis
chrubis@suse.cz

-- 
Mailing list info: https://lists.linux.it/listinfo/ltp

[LTP] [PATCH v7 0/2] ioctl_fiemap01: New test for fiemap ioctl()

[Wei Gao via ltp]

Changes v6-v7:
* Update check_extent function parameter 
* New check_extent_count function
* Other small updates base Cyril's comments on v6

link to v6:
https://patchwork.ozlabs.org/project/ltp/patch/20250410054956.5071-3-wegao@suse.com/

Wei Gao (2):
  tst_safe_macros.h: Add SAFE_STATVFS
  ioctl_fiemap01: New test for fiemap ioctl()

 include/tst_safe_macros.h                     |   6 +
 lib/tst_safe_macros.c                         |  19 +++
 runtest/syscalls                              |   1 +
 testcases/kernel/syscalls/ioctl/.gitignore    |   1 +
 .../kernel/syscalls/ioctl/ioctl_fiemap01.c    | 126 ++++++++++++++++++
 5 files changed, 153 insertions(+)
 create mode 100644 testcases/kernel/syscalls/ioctl/ioctl_fiemap01.c

-- 
2.49.0


-- 
Mailing list info: https://lists.linux.it/listinfo/ltp

[LTP] [PATCH v7 1/2] tst_safe_macros.h: Add SAFE_STATVFS

[Wei Gao via ltp]

Signed-off-by: Wei Gao <wegao@suse.com>
Reviewed-by: Petr Vorel <pvorel@suse.cz>
---
 include/tst_safe_macros.h |  6 ++++++
 lib/tst_safe_macros.c     | 19 +++++++++++++++++++
 2 files changed, 25 insertions(+)

diff --git a/include/tst_safe_macros.h b/include/tst_safe_macros.h
index 3b02f86c7..19504beb5 100644
--- a/include/tst_safe_macros.h
+++ b/include/tst_safe_macros.h
@@ -12,6 +12,7 @@
 #include <sys/time.h>
 #include <sys/resource.h>
 #include <sys/stat.h>
+#include <sys/statvfs.h>
 #include <sys/vfs.h>
 #include <sys/sysinfo.h>
 #include <sys/uio.h>
@@ -503,4 +504,9 @@ char *safe_ptsname(const char *const file, const int lineno, int masterfd);
 #define SAFE_PTSNAME(masterfd) \
 	safe_ptsname(__FILE__, __LINE__, (masterfd))
 
+int safe_statvfs(const char *file, const int lineno,
+                              const char *path, struct statvfs *buf);
+#define SAFE_STATVFS(path, buf) \
+	safe_statvfs(__FILE__, __LINE__, (path), (buf))
+
 #endif /* TST_SAFE_MACROS_H__ */
diff --git a/lib/tst_safe_macros.c b/lib/tst_safe_macros.c
index ba095a621..cdc8c7dd3 100644
--- a/lib/tst_safe_macros.c
+++ b/lib/tst_safe_macros.c
@@ -810,3 +810,22 @@ char *safe_ptsname(const char *const file, const int lineno, int masterfd)
 
 	return name;
 }
+
+int safe_statvfs(const char *file, const int lineno,
+                              const char *path, struct statvfs *buf)
+{
+	int rval;
+
+	rval = statvfs(path, buf);
+
+	if (rval == -1) {
+		tst_brk_(file, lineno, TBROK | TERRNO,
+			"statvfs(%s,%p) failed", path, buf);
+	} else if (rval) {
+		tst_brk_(file, lineno, TBROK | TERRNO,
+			"Invalid statvfs(%s,%p) return value %d", path, buf,
+			rval);
+	}
+
+	return rval;
+}
-- 
2.49.0


-- 
Mailing list info: https://lists.linux.it/listinfo/ltp

[LTP] [PATCH v7 2/2] ioctl_fiemap01: New test for fiemap ioctl()

[Wei Gao via ltp]

Fixes: #535
Local test show EOPNOTSUPP on exfat/vfat/ntfs/tmpfs,
so descope related file system currently.

Signed-off-by: Wei Gao <wegao@suse.com>
---
 runtest/syscalls                              |   1 +
 testcases/kernel/syscalls/ioctl/.gitignore    |   1 +
 .../kernel/syscalls/ioctl/ioctl_fiemap01.c    | 126 ++++++++++++++++++
 3 files changed, 128 insertions(+)
 create mode 100644 testcases/kernel/syscalls/ioctl/ioctl_fiemap01.c

diff --git a/runtest/syscalls b/runtest/syscalls
index 77e3c942f..932b7030c 100644
--- a/runtest/syscalls
+++ b/runtest/syscalls
@@ -609,6 +609,7 @@ ioctl_ficlone02 ioctl_ficlone02
 ioctl_ficlone03 ioctl_ficlone03
 ioctl_ficlonerange01 ioctl_ficlonerange01
 ioctl_ficlonerange02 ioctl_ficlonerange02
+ioctl_fiemap01 ioctl_fiemap01
 
 inotify_init1_01 inotify_init1_01
 inotify_init1_02 inotify_init1_02
diff --git a/testcases/kernel/syscalls/ioctl/.gitignore b/testcases/kernel/syscalls/ioctl/.gitignore
index 1f099ff95..53a82bb57 100644
--- a/testcases/kernel/syscalls/ioctl/.gitignore
+++ b/testcases/kernel/syscalls/ioctl/.gitignore
@@ -28,3 +28,4 @@
 /ioctl_ficlone04
 /ioctl_ficlonerange01
 /ioctl_ficlonerange02
+/ioctl_fiemap01
diff --git a/testcases/kernel/syscalls/ioctl/ioctl_fiemap01.c b/testcases/kernel/syscalls/ioctl/ioctl_fiemap01.c
new file mode 100644
index 000000000..da145e68b
--- /dev/null
+++ b/testcases/kernel/syscalls/ioctl/ioctl_fiemap01.c
@@ -0,0 +1,126 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+/*
+ * Copyright (c) 2025 Wei Gao <wegao@suse.com>
+ */
+
+/*\
+ * Verify basic fiemap ioctl functionality, including:
+ *
+ * - The ioctl returns EBADR if it receives invalid fm_flags.
+ * - 0 extents are reported for an empty file.
+ * - The ioctl correctly retrieves single and multiple extent mappings after writing to the file.
+ */
+
+#include <linux/fs.h>
+#include <linux/fiemap.h>
+#include <stdlib.h>
+#include <sys/statvfs.h>
+
+#include "tst_test.h"
+
+#define MNTPOINT "mntpoint"
+#define TESTFILE "testfile"
+#define NUM_EXTENT 3
+
+static void print_extens(struct fiemap *fiemap)
+{
+	tst_res(TDEBUG, "File extent count: %u", fiemap->fm_mapped_extents);
+
+	for (unsigned int i = 0; i < fiemap->fm_mapped_extents; ++i) {
+		tst_res(TDEBUG, "Extent %u: Logical offset: %llu, Physical offset: %llu, flags: %u, Length: %llu",
+				i + 1,
+				fiemap->fm_extents[i].fe_logical,
+				fiemap->fm_extents[i].fe_physical,
+				fiemap->fm_extents[i].fe_flags,
+				fiemap->fm_extents[i].fe_length);
+	}
+}
+
+static void check_extent_count(struct fiemap *fiemap, unsigned int fm_mapped_extents)
+{
+	TST_EXP_EXPR(fiemap->fm_mapped_extents == fm_mapped_extents,
+		"Check extent fm_mapped_extents is %d", fm_mapped_extents);
+}
+
+static void check_extent(struct fiemap *fiemap,	int index_extents, unsigned int fe_mask,
+					unsigned int fe_flags, unsigned int fe_length)
+{
+	struct fiemap_extent *extent = &fiemap->fm_extents[index_extents];
+
+	TST_EXP_EQ_LU((extent->fe_flags & fe_mask), fe_flags);
+	TST_EXP_EXPR(extent->fe_physical >= 1, "Check fe_physical > %d", 1);
+	TST_EXP_EQ_LU(extent->fe_length, fe_length);
+}
+
+static void verify_ioctl(void)
+{
+	int fd;
+	struct fiemap *fiemap;
+	struct statvfs fs_info;
+	unsigned long blk_size;
+
+	fd = SAFE_OPEN(TESTFILE, O_RDWR | O_CREAT, 0644);
+
+	SAFE_STATVFS(".", &fs_info);
+
+	blk_size = fs_info.f_bsize;
+
+	fiemap = SAFE_MALLOC(sizeof(struct fiemap) + sizeof(struct fiemap_extent) * NUM_EXTENT);
+	fiemap->fm_start = 0;
+	fiemap->fm_length = ~0ULL;
+	fiemap->fm_extent_count = 1;
+
+	fiemap->fm_flags = -1;
+	TST_EXP_FAIL(ioctl(fd, FS_IOC_FIEMAP, fiemap), EBADR);
+
+	fiemap->fm_flags =  0;
+	TST_EXP_PASS(ioctl(fd, FS_IOC_FIEMAP, fiemap));
+	print_extens(fiemap);
+	TST_EXP_EXPR(fiemap->fm_mapped_extents == 0,
+		"Empty file should have 0 extends mapped");
+
+	char *buf = SAFE_MALLOC(blk_size);
+
+	SAFE_WRITE(SAFE_WRITE_ANY, fd, buf, blk_size);
+	fiemap->fm_flags = FIEMAP_FLAG_SYNC;
+	TST_EXP_PASS(ioctl(fd, FS_IOC_FIEMAP, fiemap));
+	print_extens(fiemap);
+	check_extent_count(fiemap, 1);
+	check_extent(fiemap, 0, FIEMAP_EXTENT_LAST, FIEMAP_EXTENT_LAST, blk_size);
+
+	fiemap->fm_extent_count = NUM_EXTENT;
+	SAFE_LSEEK(fd, 2 * blk_size, SEEK_SET);
+	SAFE_WRITE(SAFE_WRITE_ALL, fd, buf, blk_size);
+	SAFE_LSEEK(fd, 4 * blk_size, SEEK_SET);
+	SAFE_WRITE(SAFE_WRITE_ALL, fd, buf, blk_size);
+	TST_EXP_PASS(ioctl(fd, FS_IOC_FIEMAP, fiemap));
+	print_extens(fiemap);
+	check_extent_count(fiemap, NUM_EXTENT);
+
+	for (int i = 0; i < NUM_EXTENT - 1; i++)
+		check_extent(fiemap, i, FIEMAP_EXTENT_LAST, 0, blk_size);
+
+	check_extent(fiemap, NUM_EXTENT - 1, FIEMAP_EXTENT_LAST, FIEMAP_EXTENT_LAST, blk_size);
+
+	free(buf);
+	free(fiemap);
+	SAFE_CLOSE(fd);
+	SAFE_UNLINK(TESTFILE);
+}
+
+static void setup(void)
+{
+	SAFE_CHDIR(MNTPOINT);
+}
+
+static struct tst_test test = {
+	.setup = setup,
+	.mount_device = 1,
+	.mntpoint = MNTPOINT,
+	.all_filesystems = 1,
+	.skip_filesystems = (const char *const[]) {
+		"exfat", "vfat", "fuse", "ntfs", "tmpfs", NULL
+	},
+	.test_all = verify_ioctl,
+	.needs_root = 1,
+};
-- 
2.49.0


-- 
Mailing list info: https://lists.linux.it/listinfo/ltp

Re: [LTP] [PATCH v7 2/2] ioctl_fiemap01: New test for fiemap ioctl()

[Cyril Hrubis]

Hi!
Pushed with a minor change, thanks.

> +	TST_EXP_EQ_LU((extent->fe_flags & fe_mask), fe_flags);
> +	TST_EXP_EXPR(extent->fe_physical >= 1, "Check fe_physical > %d", 1);
                                                 ^
						 The macro already
						 prints "Expect: " in
						 the message so the
						 "Check " here is
						 redundant.

Hence I've removed the "Check " part from the two macros in the test
before pushing.

-- 
Cyril Hrubis
chrubis@suse.cz

-- 
Mailing list info: https://lists.linux.it/listinfo/ltp