tools/testing/selftests/filesystems/openat2/openat2_test.c - linux - Git at Google

 // SPDX-License-Identifier: GPL-2.0-or-later
 /*
  * Author: Aleksa Sarai <cyphar@cyphar.com>
  * Copyright (C) 2018-2019 SUSE LLC.
  */

 #define _GNU_SOURCE
 #define __SANE_USERSPACE_TYPES__ // Use ll64
 #include <fcntl.h>
 #include <sched.h>
 #include <sys/stat.h>
 #include <sys/types.h>
 #include <sys/mount.h>
 #include <stdlib.h>
 #include <stdbool.h>
 #include <string.h>

 #include "helpers.h"
 #include "kselftest_harness.h"

 /*
  * O_LARGEFILE is set to 0 by glibc.
  * XXX: This is wrong on {mips, parisc, powerpc, sparc}.
  */
 #undef	O_LARGEFILE
 #ifdef __aarch64__
 #define	O_LARGEFILE 0x20000
 #else
 #define	O_LARGEFILE 0x8000
 #endif

 struct open_how_ext {
 	struct open_how inner;
 	uint32_t extra1;
 	char pad1[128];
 	uint32_t extra2;
 	char pad2[128];
 	uint32_t extra3;
 };

 struct struct_test {
 	const char *name;
 	struct open_how_ext arg;
 	size_t size;
 	int err;
 };

 struct flag_test {
 	const char *name;
 	struct open_how how;
 	int err;
 };

 FIXTURE(openat2) {};

 FIXTURE_SETUP(openat2)
 {
 	if (!openat2_supported)
 		SKIP(return, "openat2(2) not supported");
 }

 FIXTURE_TEARDOWN(openat2) {}

 /*
  * Verify that the struct size and misalignment handling for openat2(2) is
  * correct, including that is_zeroed_user() works.
  */
 TEST_F(openat2, struct_argument_sizes)
 {
 	int misalignments[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 17, 87 };
 	struct struct_test tests[] = {
 		/* Normal struct. */
 		{ .name = "normal struct",
 		  .arg.inner.flags = O_RDONLY,
 		  .size = sizeof(struct open_how) },
 		/* Bigger struct, with zeroed out end. */
 		{ .name = "bigger struct (zeroed out)",
 		  .arg.inner.flags = O_RDONLY,
 		  .size = sizeof(struct open_how_ext) },

 		/* TODO: Once expanded, check zero-padding. */

 		/* Smaller than version-0 struct. */
 		{ .name = "zero-sized 'struct'",
 		  .arg.inner.flags = O_RDONLY, .size = 0, .err = -EINVAL },
 		{ .name = "smaller-than-v0 struct",
 		  .arg.inner.flags = O_RDONLY,
 		  .size = OPEN_HOW_SIZE_VER0 - 1, .err = -EINVAL },

 		/* Bigger struct, with non-zero trailing bytes. */
 		{ .name = "bigger struct (non-zero data in first 'future field')",
 		  .arg.inner.flags = O_RDONLY, .arg.extra1 = 0xdeadbeef,
 		  .size = sizeof(struct open_how_ext), .err = -E2BIG },
 		{ .name = "bigger struct (non-zero data in middle of 'future fields')",
 		  .arg.inner.flags = O_RDONLY, .arg.extra2 = 0xfeedcafe,
 		  .size = sizeof(struct open_how_ext), .err = -E2BIG },
 		{ .name = "bigger struct (non-zero data at end of 'future fields')",
 		  .arg.inner.flags = O_RDONLY, .arg.extra3 = 0xabad1dea,
 		  .size = sizeof(struct open_how_ext), .err = -E2BIG },
 	};

 	for (int i = 0; i < ARRAY_SIZE(tests); i++) {
 		struct struct_test *test = &tests[i];
 		struct open_how_ext how_ext = test->arg;

 		for (int j = 0; j < ARRAY_SIZE(misalignments); j++) {
 			int fd, misalign = misalignments[j];
 			void *copy = NULL, *how_copy = &how_ext;
 			char *fdpath = NULL;

 			if (misalign) {
 				/*
 				 * Explicitly misalign the structure copying it with the given
 				 * (mis)alignment offset. The other data is set to be non-zero to
 				 * make sure that non-zero bytes outside the struct aren't checked
 				 *
 				 * This is effectively to check that is_zeroed_user() works.
 				 */
 				copy = malloc(misalign + sizeof(how_ext));
 				how_copy = copy + misalign;
 				memset(copy, 0xff, misalign);
 				memcpy(how_copy, &how_ext, sizeof(how_ext));
 			}

 			fd = raw_openat2(AT_FDCWD, ".", how_copy, test->size);
 			if (fd >= 0) {
 				fdpath = fdreadlink(_metadata, fd);
 				close(fd);
 			}

 			if (test->err >= 0) {
 				EXPECT_GE(fd, 0) {
 					TH_LOG("openat2 with %s [misalign=%d] should succeed, got %d (%s)",
 					       test->name, misalign,
 					       fd, strerror(-fd));
 				}
 			} else {
 				EXPECT_EQ(test->err, fd) {
 					if (fdpath)
 						TH_LOG("openat2 with %s [misalign=%d] should fail with %d (%s), got %d['%s']",
 						       test->name, misalign,
 						       test->err,
 						       strerror(-test->err),
 						       fd, fdpath);
 					else
 						TH_LOG("openat2 with %s [misalign=%d] should fail with %d (%s), got %d (%s)",
 						       test->name, misalign,
 						       test->err,
 						       strerror(-test->err),
 						       fd, strerror(-fd));
 				}
 			}

 			free(copy);
 			free(fdpath);
 		}
 	}
 }

 /* Verify openat2(2) flag and mode validation. */
 TEST_F(openat2, flag_validation)
 {
 	struct flag_test tests[] = {
 		/* O_TMPFILE is incompatible with O_PATH and O_CREAT. */
 		{ .name = "incompatible flags (O_TMPFILE | O_PATH)",
 		  .how.flags = O_TMPFILE | O_PATH | O_RDWR, .err = -EINVAL },
 		{ .name = "incompatible flags (O_TMPFILE | O_CREAT)",
 		  .how.flags = O_TMPFILE | O_CREAT | O_RDWR, .err = -EINVAL },

 		/* O_PATH only permits certain other flags to be set ... */
 		{ .name = "compatible flags (O_PATH | O_CLOEXEC)",
 		  .how.flags = O_PATH | O_CLOEXEC },
 		{ .name = "compatible flags (O_PATH | O_DIRECTORY)",
 		  .how.flags = O_PATH | O_DIRECTORY },
 		{ .name = "compatible flags (O_PATH | O_NOFOLLOW)",
 		  .how.flags = O_PATH | O_NOFOLLOW },
 		/* ... and others are absolutely not permitted. */
 		{ .name = "incompatible flags (O_PATH | O_RDWR)",
 		  .how.flags = O_PATH | O_RDWR, .err = -EINVAL },
 		{ .name = "incompatible flags (O_PATH | O_CREAT)",
 		  .how.flags = O_PATH | O_CREAT, .err = -EINVAL },
 		{ .name = "incompatible flags (O_PATH | O_EXCL)",
 		  .how.flags = O_PATH | O_EXCL, .err = -EINVAL },
 		{ .name = "incompatible flags (O_PATH | O_NOCTTY)",
 		  .how.flags = O_PATH | O_NOCTTY, .err = -EINVAL },
 		{ .name = "incompatible flags (O_PATH | O_DIRECT)",
 		  .how.flags = O_PATH | O_DIRECT, .err = -EINVAL },
 		{ .name = "incompatible flags (O_PATH | O_LARGEFILE)",
 		  .how.flags = O_PATH | O_LARGEFILE, .err = -EINVAL },

 		/* ->mode must only be set with O_{CREAT,TMPFILE}. */
 		{ .name = "non-zero how.mode and O_RDONLY",
 		  .how.flags = O_RDONLY, .how.mode = 0600, .err = -EINVAL },
 		{ .name = "non-zero how.mode and O_PATH",
 		  .how.flags = O_PATH,   .how.mode = 0600, .err = -EINVAL },
 		{ .name = "valid how.mode and O_CREAT",
 		  .how.flags = O_CREAT,  .how.mode = 0600 },
 		{ .name = "valid how.mode and O_TMPFILE",
 		  .how.flags = O_TMPFILE | O_RDWR, .how.mode = 0600 },
 		/* ->mode must only contain 0777 bits. */
 		{ .name = "invalid how.mode and O_CREAT",
 		  .how.flags = O_CREAT,
 		  .how.mode = 0xFFFF, .err = -EINVAL },
 		{ .name = "invalid (very large) how.mode and O_CREAT",
 		  .how.flags = O_CREAT,
 		  .how.mode = 0xC000000000000000ULL, .err = -EINVAL },
 		{ .name = "invalid how.mode and O_TMPFILE",
 		  .how.flags = O_TMPFILE | O_RDWR,
 		  .how.mode = 0x1337, .err = -EINVAL },
 		{ .name = "invalid (very large) how.mode and O_TMPFILE",
 		  .how.flags = O_TMPFILE | O_RDWR,
 		  .how.mode = 0x0000A00000000000ULL, .err = -EINVAL },

 		/* ->resolve flags must not conflict. */
 		{ .name = "incompatible resolve flags (BENEATH | IN_ROOT)",
 		  .how.flags = O_RDONLY,
 		  .how.resolve = RESOLVE_BENEATH | RESOLVE_IN_ROOT,
 		  .err = -EINVAL },

 		/* ->resolve must only contain RESOLVE_* flags. */
 		{ .name = "invalid how.resolve and O_RDONLY",
 		  .how.flags = O_RDONLY,
 		  .how.resolve = 0x1337, .err = -EINVAL },
 		{ .name = "invalid how.resolve and O_CREAT",
 		  .how.flags = O_CREAT,
 		  .how.resolve = 0x1337, .err = -EINVAL },
 		{ .name = "invalid how.resolve and O_TMPFILE",
 		  .how.flags = O_TMPFILE | O_RDWR,
 		  .how.resolve = 0x1337, .err = -EINVAL },
 		{ .name = "invalid how.resolve and O_PATH",
 		  .how.flags = O_PATH,
 		  .how.resolve = 0x1337, .err = -EINVAL },

 		/* currently unknown upper 32 bit rejected. */
 		{ .name = "currently unknown bit (1 << 63)",
 		  .how.flags = O_RDONLY | (1ULL << 63),
 		  .how.resolve = 0, .err = -EINVAL },
 	};

 	for (int i = 0; i < ARRAY_SIZE(tests); i++) {
 		int fd, fdflags = -1;
 		char *path, *fdpath = NULL;
 		struct flag_test *test = &tests[i];

 		path = (test->how.flags & O_CREAT) ? "/tmp/ksft.openat2_tmpfile" : ".";
 		unlink(path);

 		fd = sys_openat2(AT_FDCWD, path, &test->how);
 		if (fd < 0 && fd == -EOPNOTSUPP) {
 			/*
 			 * Skip the testcase if it failed because not supported
 			 * by FS. (e.g. a valid O_TMPFILE combination on NFS)
 			 */
 			TH_LOG("openat2 with %s not supported by FS -- skipping",
 			       test->name);
 			continue;
 		}

 		if (test->err >= 0) {
 			EXPECT_GE(fd, 0) {
 				TH_LOG("openat2 with %s should succeed, got %d (%s)",
 				       test->name, fd, strerror(-fd));
 			}
 			if (fd >= 0) {
 				int otherflags;

 				fdpath = fdreadlink(_metadata, fd);
 				fdflags = fcntl(fd, F_GETFL);
 				otherflags = fcntl(fd, F_GETFD);
 				close(fd);

 				ASSERT_GE(fdflags, 0);
 				ASSERT_GE(otherflags, 0);

 				/* O_CLOEXEC isn't shown in F_GETFL. */
 				if (otherflags & FD_CLOEXEC)
 					fdflags |= O_CLOEXEC;
 				/* O_CREAT is hidden from F_GETFL. */
 				if (test->how.flags & O_CREAT)
 					fdflags |= O_CREAT;
 				if (!(test->how.flags & O_LARGEFILE))
 					fdflags &= ~O_LARGEFILE;

 				EXPECT_EQ(fdflags, (int)test->how.flags) {
 					TH_LOG("openat2 with %s: flags mismatch %X != %llX",
 					       test->name, fdflags,
 					       (unsigned long long)test->how.flags);
 				}
 			}
 		} else {
 			EXPECT_EQ(test->err, fd) {
 				if (fd >= 0) {
 					fdpath = fdreadlink(_metadata, fd);
 					TH_LOG("openat2 with %s should fail with %d (%s), got %d['%s']",
 					       test->name, test->err,
 					       strerror(-test->err),
 					       fd, fdpath);
 				} else {
 					TH_LOG("openat2 with %s should fail with %d (%s), got %d (%s)",
 					       test->name, test->err,
 					       strerror(-test->err),
 					       fd, strerror(-fd));
 				}
 			}
 			if (fd >= 0)
 				close(fd);
 		}

 		free(fdpath);
 	}
 }

 #ifndef OPENAT2_REGULAR
 #define OPENAT2_REGULAR ((__u64)1 << 32)
 #endif

 #ifndef EFTYPE
 #define EFTYPE 134
 #endif

 /* Kernel-internal carrier for OPENAT2_REGULAR (see __O_REGULAR in fcntl.h). */
 #ifndef __O_REGULAR
 #define __O_REGULAR (1 << 30)
 #endif

 /* Verify that OPENAT2_REGULAR rejects non-regular files with EFTYPE. */
 TEST_F(openat2, regular_flag)
 {
 	struct open_how how = {
 		.flags = OPENAT2_REGULAR | O_RDONLY,
 	};
 	int fd;

 	fd = sys_openat2(AT_FDCWD, "/dev/null", &how);
 	if (fd == -ENOENT)
 		SKIP(return, "/dev/null does not exist");

 	EXPECT_EQ(-EFTYPE, fd) {
 		TH_LOG("openat2 with OPENAT2_REGULAR should fail with %d (%s), got %d (%s)",
 		       -EFTYPE, strerror(EFTYPE), fd, strerror(-fd));
 	}
 	if (fd >= 0)
 		close(fd);
 }

 /* open()/openat() must keep ignoring the internal __O_REGULAR bit. */
 TEST(legacy_openat_ignores_o_regular)
 {
 	int fd;

 	fd = openat(AT_FDCWD, "/dev/null", O_RDONLY | __O_REGULAR);
 	if (fd < 0 && errno == ENOENT)
 		SKIP(return, "/dev/null does not exist");

 	ASSERT_GE(fd, 0) {
 		TH_LOG("legacy openat() must ignore the __O_REGULAR carrier bit, got errno %d (%s)",
 		       errno, strerror(errno));
 	}
 	close(fd);
 }

 TEST_HARNESS_MAIN
	// SPDX-License-Identifier: GPL-2.0-or-later
	/*
	* Author: Aleksa Sarai <cyphar@cyphar.com>
	* Copyright (C) 2018-2019 SUSE LLC.
	*/

	#define _GNU_SOURCE
	#define __SANE_USERSPACE_TYPES__ // Use ll64
	#include <fcntl.h>
	#include <sched.h>
	#include <sys/stat.h>
	#include <sys/types.h>
	#include <sys/mount.h>
	#include <stdlib.h>
	#include <stdbool.h>
	#include <string.h>

	#include "helpers.h"
	#include "kselftest_harness.h"

	/*
	* O_LARGEFILE is set to 0 by glibc.
	* XXX: This is wrong on {mips, parisc, powerpc, sparc}.
	*/
	#undef O_LARGEFILE
	#ifdef __aarch64__
	#define O_LARGEFILE 0x20000
	#else
	#define O_LARGEFILE 0x8000
	#endif

	struct open_how_ext {
	struct open_how inner;
	uint32_t extra1;
	char pad1[128];
	uint32_t extra2;
	char pad2[128];
	uint32_t extra3;
	};

	struct struct_test {
	const char *name;
	struct open_how_ext arg;
	size_t size;
	int err;
	};

	struct flag_test {
	const char *name;
	struct open_how how;
	int err;
	};

	FIXTURE(openat2) {};

	FIXTURE_SETUP(openat2)
	{
	if (!openat2_supported)
	SKIP(return, "openat2(2) not supported");
	}

	FIXTURE_TEARDOWN(openat2) {}

	/*
	* Verify that the struct size and misalignment handling for openat2(2) is
	* correct, including that is_zeroed_user() works.
	*/
	TEST_F(openat2, struct_argument_sizes)
	{
	int misalignments[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 17, 87 };
	struct struct_test tests[] = {
	/* Normal struct. */
	{ .name = "normal struct",
	.arg.inner.flags = O_RDONLY,
	.size = sizeof(struct open_how) },
	/* Bigger struct, with zeroed out end. */
	{ .name = "bigger struct (zeroed out)",
	.arg.inner.flags = O_RDONLY,
	.size = sizeof(struct open_how_ext) },

	/* TODO: Once expanded, check zero-padding. */

	/* Smaller than version-0 struct. */
	{ .name = "zero-sized 'struct'",
	.arg.inner.flags = O_RDONLY, .size = 0, .err = -EINVAL },
	{ .name = "smaller-than-v0 struct",
	.arg.inner.flags = O_RDONLY,
	.size = OPEN_HOW_SIZE_VER0 - 1, .err = -EINVAL },

	/* Bigger struct, with non-zero trailing bytes. */
	{ .name = "bigger struct (non-zero data in first 'future field')",
	.arg.inner.flags = O_RDONLY, .arg.extra1 = 0xdeadbeef,
	.size = sizeof(struct open_how_ext), .err = -E2BIG },
	{ .name = "bigger struct (non-zero data in middle of 'future fields')",
	.arg.inner.flags = O_RDONLY, .arg.extra2 = 0xfeedcafe,
	.size = sizeof(struct open_how_ext), .err = -E2BIG },
	{ .name = "bigger struct (non-zero data at end of 'future fields')",
	.arg.inner.flags = O_RDONLY, .arg.extra3 = 0xabad1dea,
	.size = sizeof(struct open_how_ext), .err = -E2BIG },
	};

	for (int i = 0; i < ARRAY_SIZE(tests); i++) {
	struct struct_test *test = &tests[i];
	struct open_how_ext how_ext = test->arg;

	for (int j = 0; j < ARRAY_SIZE(misalignments); j++) {
	int fd, misalign = misalignments[j];
	void copy = NULL, how_copy = &how_ext;
	char *fdpath = NULL;

	if (misalign) {
	/*
	* Explicitly misalign the structure copying it with the given
	* (mis)alignment offset. The other data is set to be non-zero to
	* make sure that non-zero bytes outside the struct aren't checked
	*
	* This is effectively to check that is_zeroed_user() works.
	*/
	copy = malloc(misalign + sizeof(how_ext));
	how_copy = copy + misalign;
	memset(copy, 0xff, misalign);
	memcpy(how_copy, &how_ext, sizeof(how_ext));
	}

	fd = raw_openat2(AT_FDCWD, ".", how_copy, test->size);
	if (fd >= 0) {
	fdpath = fdreadlink(_metadata, fd);
	close(fd);
	}

	if (test->err >= 0) {
	EXPECT_GE(fd, 0) {
	TH_LOG("openat2 with %s [misalign=%d] should succeed, got %d (%s)",
	test->name, misalign,
	fd, strerror(-fd));
	}
	} else {
	EXPECT_EQ(test->err, fd) {
	if (fdpath)
	TH_LOG("openat2 with %s [misalign=%d] should fail with %d (%s), got %d['%s']",
	test->name, misalign,
	test->err,
	strerror(-test->err),
	fd, fdpath);
	else
	TH_LOG("openat2 with %s [misalign=%d] should fail with %d (%s), got %d (%s)",
	test->name, misalign,
	test->err,
	strerror(-test->err),
	fd, strerror(-fd));
	}
	}

	free(copy);
	free(fdpath);
	}
	}
	}

	/* Verify openat2(2) flag and mode validation. */
	TEST_F(openat2, flag_validation)
	{
	struct flag_test tests[] = {
	/* O_TMPFILE is incompatible with O_PATH and O_CREAT. */
	{ .name = "incompatible flags (O_TMPFILE \| O_PATH)",
	.how.flags = O_TMPFILE \| O_PATH \| O_RDWR, .err = -EINVAL },
	{ .name = "incompatible flags (O_TMPFILE \| O_CREAT)",
	.how.flags = O_TMPFILE \| O_CREAT \| O_RDWR, .err = -EINVAL },

	/* O_PATH only permits certain other flags to be set ... */
	{ .name = "compatible flags (O_PATH \| O_CLOEXEC)",
	.how.flags = O_PATH \| O_CLOEXEC },
	{ .name = "compatible flags (O_PATH \| O_DIRECTORY)",
	.how.flags = O_PATH \| O_DIRECTORY },
	{ .name = "compatible flags (O_PATH \| O_NOFOLLOW)",
	.how.flags = O_PATH \| O_NOFOLLOW },
	/* ... and others are absolutely not permitted. */
	{ .name = "incompatible flags (O_PATH \| O_RDWR)",
	.how.flags = O_PATH \| O_RDWR, .err = -EINVAL },
	{ .name = "incompatible flags (O_PATH \| O_CREAT)",
	.how.flags = O_PATH \| O_CREAT, .err = -EINVAL },
	{ .name = "incompatible flags (O_PATH \| O_EXCL)",
	.how.flags = O_PATH \| O_EXCL, .err = -EINVAL },
	{ .name = "incompatible flags (O_PATH \| O_NOCTTY)",
	.how.flags = O_PATH \| O_NOCTTY, .err = -EINVAL },
	{ .name = "incompatible flags (O_PATH \| O_DIRECT)",
	.how.flags = O_PATH \| O_DIRECT, .err = -EINVAL },
	{ .name = "incompatible flags (O_PATH \| O_LARGEFILE)",
	.how.flags = O_PATH \| O_LARGEFILE, .err = -EINVAL },

	/* ->mode must only be set with O_{CREAT,TMPFILE}. */
	{ .name = "non-zero how.mode and O_RDONLY",
	.how.flags = O_RDONLY, .how.mode = 0600, .err = -EINVAL },
	{ .name = "non-zero how.mode and O_PATH",
	.how.flags = O_PATH, .how.mode = 0600, .err = -EINVAL },
	{ .name = "valid how.mode and O_CREAT",
	.how.flags = O_CREAT, .how.mode = 0600 },
	{ .name = "valid how.mode and O_TMPFILE",
	.how.flags = O_TMPFILE \| O_RDWR, .how.mode = 0600 },
	/* ->mode must only contain 0777 bits. */
	{ .name = "invalid how.mode and O_CREAT",
	.how.flags = O_CREAT,
	.how.mode = 0xFFFF, .err = -EINVAL },
	{ .name = "invalid (very large) how.mode and O_CREAT",
	.how.flags = O_CREAT,
	.how.mode = 0xC000000000000000ULL, .err = -EINVAL },
	{ .name = "invalid how.mode and O_TMPFILE",
	.how.flags = O_TMPFILE \| O_RDWR,
	.how.mode = 0x1337, .err = -EINVAL },
	{ .name = "invalid (very large) how.mode and O_TMPFILE",
	.how.flags = O_TMPFILE \| O_RDWR,
	.how.mode = 0x0000A00000000000ULL, .err = -EINVAL },

	/* ->resolve flags must not conflict. */
	{ .name = "incompatible resolve flags (BENEATH \| IN_ROOT)",
	.how.flags = O_RDONLY,
	.how.resolve = RESOLVE_BENEATH \| RESOLVE_IN_ROOT,
	.err = -EINVAL },

	/* ->resolve must only contain RESOLVE_* flags. */
	{ .name = "invalid how.resolve and O_RDONLY",
	.how.flags = O_RDONLY,
	.how.resolve = 0x1337, .err = -EINVAL },
	{ .name = "invalid how.resolve and O_CREAT",
	.how.flags = O_CREAT,
	.how.resolve = 0x1337, .err = -EINVAL },
	{ .name = "invalid how.resolve and O_TMPFILE",
	.how.flags = O_TMPFILE \| O_RDWR,
	.how.resolve = 0x1337, .err = -EINVAL },
	{ .name = "invalid how.resolve and O_PATH",
	.how.flags = O_PATH,
	.how.resolve = 0x1337, .err = -EINVAL },

	/* currently unknown upper 32 bit rejected. */
	{ .name = "currently unknown bit (1 << 63)",
	.how.flags = O_RDONLY \| (1ULL << 63),
	.how.resolve = 0, .err = -EINVAL },
	};

	for (int i = 0; i < ARRAY_SIZE(tests); i++) {
	int fd, fdflags = -1;
	char path, fdpath = NULL;
	struct flag_test *test = &tests[i];

	path = (test->how.flags & O_CREAT) ? "/tmp/ksft.openat2_tmpfile" : ".";
	unlink(path);

	fd = sys_openat2(AT_FDCWD, path, &test->how);
	if (fd < 0 && fd == -EOPNOTSUPP) {
	/*
	* Skip the testcase if it failed because not supported
	* by FS. (e.g. a valid O_TMPFILE combination on NFS)
	*/
	TH_LOG("openat2 with %s not supported by FS -- skipping",
	test->name);
	continue;
	}

	if (test->err >= 0) {
	EXPECT_GE(fd, 0) {
	TH_LOG("openat2 with %s should succeed, got %d (%s)",
	test->name, fd, strerror(-fd));
	}
	if (fd >= 0) {
	int otherflags;

	fdpath = fdreadlink(_metadata, fd);
	fdflags = fcntl(fd, F_GETFL);
	otherflags = fcntl(fd, F_GETFD);
	close(fd);

	ASSERT_GE(fdflags, 0);
	ASSERT_GE(otherflags, 0);

	/* O_CLOEXEC isn't shown in F_GETFL. */
	if (otherflags & FD_CLOEXEC)
	fdflags \|= O_CLOEXEC;
	/* O_CREAT is hidden from F_GETFL. */
	if (test->how.flags & O_CREAT)
	fdflags \|= O_CREAT;
	if (!(test->how.flags & O_LARGEFILE))
	fdflags &= ~O_LARGEFILE;

	EXPECT_EQ(fdflags, (int)test->how.flags) {
	TH_LOG("openat2 with %s: flags mismatch %X != %llX",
	test->name, fdflags,
	(unsigned long long)test->how.flags);
	}
	}
	} else {
	EXPECT_EQ(test->err, fd) {
	if (fd >= 0) {
	fdpath = fdreadlink(_metadata, fd);
	TH_LOG("openat2 with %s should fail with %d (%s), got %d['%s']",
	test->name, test->err,
	strerror(-test->err),
	fd, fdpath);
	} else {
	TH_LOG("openat2 with %s should fail with %d (%s), got %d (%s)",
	test->name, test->err,
	strerror(-test->err),
	fd, strerror(-fd));
	}
	}
	if (fd >= 0)
	close(fd);
	}

	free(fdpath);
	}
	}

	#ifndef OPENAT2_REGULAR
	#define OPENAT2_REGULAR ((__u64)1 << 32)
	#endif

	#ifndef EFTYPE
	#define EFTYPE 134
	#endif

	/* Kernel-internal carrier for OPENAT2_REGULAR (see __O_REGULAR in fcntl.h). */
	#ifndef __O_REGULAR
	#define __O_REGULAR (1 << 30)
	#endif

	/* Verify that OPENAT2_REGULAR rejects non-regular files with EFTYPE. */
	TEST_F(openat2, regular_flag)
	{
	struct open_how how = {
	.flags = OPENAT2_REGULAR \| O_RDONLY,
	};
	int fd;

	fd = sys_openat2(AT_FDCWD, "/dev/null", &how);
	if (fd == -ENOENT)
	SKIP(return, "/dev/null does not exist");

	EXPECT_EQ(-EFTYPE, fd) {
	TH_LOG("openat2 with OPENAT2_REGULAR should fail with %d (%s), got %d (%s)",
	-EFTYPE, strerror(EFTYPE), fd, strerror(-fd));
	}
	if (fd >= 0)
	close(fd);
	}

	/* open()/openat() must keep ignoring the internal __O_REGULAR bit. */
	TEST(legacy_openat_ignores_o_regular)
	{
	int fd;

	fd = openat(AT_FDCWD, "/dev/null", O_RDONLY \| __O_REGULAR);
	if (fd < 0 && errno == ENOENT)
	SKIP(return, "/dev/null does not exist");

	ASSERT_GE(fd, 0) {
	TH_LOG("legacy openat() must ignore the __O_REGULAR carrier bit, got errno %d (%s)",
	errno, strerror(errno));
	}
	close(fd);
	}

	TEST_HARNESS_MAIN