tools/testing/selftests/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 "../kselftest.h"
 #include "helpers.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;
 };

 #define NUM_OPENAT2_STRUCT_TESTS 7
 #define NUM_OPENAT2_STRUCT_VARIATIONS 13

 void test_openat2_struct(void)
 {
 	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 },
 	};

 	BUILD_BUG_ON(ARRAY_LEN(misalignments) != NUM_OPENAT2_STRUCT_VARIATIONS);
 	BUILD_BUG_ON(ARRAY_LEN(tests) != NUM_OPENAT2_STRUCT_TESTS);

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

 		for (int j = 0; j < ARRAY_LEN(misalignments); j++) {
 			int fd, misalign = misalignments[j];
 			char *fdpath = NULL;
 			bool failed;
 			void (*resultfn)(const char *msg, ...) = ksft_test_result_pass;

 			void *copy = NULL, *how_copy = &how_ext;

 			if (!openat2_supported) {
 				ksft_print_msg("openat2(2) unsupported\n");
 				resultfn = ksft_test_result_skip;
 				goto skip;
 			}

 			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 (test->err >= 0)
 				failed = (fd < 0);
 			else
 				failed = (fd != test->err);
 			if (fd >= 0) {
 				fdpath = fdreadlink(fd);
 				close(fd);
 			}

 			if (failed) {
 				resultfn = ksft_test_result_fail;

 				ksft_print_msg("openat2 unexpectedly returned ");
 				if (fdpath)
 					ksft_print_msg("%d['%s']\n", fd, fdpath);
 				else
 					ksft_print_msg("%d (%s)\n", fd, strerror(-fd));
 			}

 skip:
 			if (test->err >= 0)
 				resultfn("openat2 with %s argument [misalign=%d] succeeds\n",
 					 test->name, misalign);
 			else
 				resultfn("openat2 with %s argument [misalign=%d] fails with %d (%s)\n",
 					 test->name, misalign, test->err,
 					 strerror(-test->err));

 			free(copy);
 			free(fdpath);
 			fflush(stdout);
 		}
 	}
 }

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

 #define NUM_OPENAT2_FLAG_TESTS 25

 void test_openat2_flags(void)
 {
 	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 },
 	};

 	BUILD_BUG_ON(ARRAY_LEN(tests) != NUM_OPENAT2_FLAG_TESTS);

 	for (int i = 0; i < ARRAY_LEN(tests); i++) {
 		int fd, fdflags = -1;
 		char *path, *fdpath = NULL;
 		bool failed = false;
 		struct flag_test *test = &tests[i];
 		void (*resultfn)(const char *msg, ...) = ksft_test_result_pass;

 		if (!openat2_supported) {
 			ksft_print_msg("openat2(2) unsupported\n");
 			resultfn = ksft_test_result_skip;
 			goto skip;
 		}

 		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)
 			 */
 			ksft_test_result_skip("openat2 with %s fails with %d (%s)\n",
 					      test->name, fd, strerror(-fd));
 			goto next;
 		}

 		if (test->err >= 0)
 			failed = (fd < 0);
 		else
 			failed = (fd != test->err);
 		if (fd >= 0) {
 			int otherflags;

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

 			E_assert(fdflags >= 0, "fcntl F_GETFL of new fd");
 			E_assert(otherflags >= 0, "fcntl F_GETFD of new fd");

 			/* 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;
 			failed |= (fdflags != test->how.flags);
 		}

 		if (failed) {
 			resultfn = ksft_test_result_fail;

 			ksft_print_msg("openat2 unexpectedly returned ");
 			if (fdpath)
 				ksft_print_msg("%d['%s'] with %X (!= %llX)\n",
 					       fd, fdpath, fdflags,
 					       test->how.flags);
 			else
 				ksft_print_msg("%d (%s)\n", fd, strerror(-fd));
 		}

 skip:
 		if (test->err >= 0)
 			resultfn("openat2 with %s succeeds\n", test->name);
 		else
 			resultfn("openat2 with %s fails with %d (%s)\n",
 				 test->name, test->err, strerror(-test->err));
 next:
 		free(fdpath);
 		fflush(stdout);
 	}
 }

 #define NUM_TESTS (NUM_OPENAT2_STRUCT_VARIATIONS * NUM_OPENAT2_STRUCT_TESTS + \
 		   NUM_OPENAT2_FLAG_TESTS)

 int main(int argc, char **argv)
 {
 	ksft_print_header();
 	ksft_set_plan(NUM_TESTS);

 	test_openat2_struct();
 	test_openat2_flags();

 	if (ksft_get_fail_cnt() + ksft_get_error_cnt() > 0)
 		ksft_exit_fail();
 	else
 		ksft_exit_pass();
 }
	// 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 "../kselftest.h"
	#include "helpers.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;
	};

	#define NUM_OPENAT2_STRUCT_TESTS 7
	#define NUM_OPENAT2_STRUCT_VARIATIONS 13

	void test_openat2_struct(void)
	{
	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 },
	};

	BUILD_BUG_ON(ARRAY_LEN(misalignments) != NUM_OPENAT2_STRUCT_VARIATIONS);
	BUILD_BUG_ON(ARRAY_LEN(tests) != NUM_OPENAT2_STRUCT_TESTS);

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

	for (int j = 0; j < ARRAY_LEN(misalignments); j++) {
	int fd, misalign = misalignments[j];
	char *fdpath = NULL;
	bool failed;
	void (resultfn)(const char msg, ...) = ksft_test_result_pass;

	void copy = NULL, how_copy = &how_ext;

	if (!openat2_supported) {
	ksft_print_msg("openat2(2) unsupported\n");
	resultfn = ksft_test_result_skip;
	goto skip;
	}

	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 (test->err >= 0)
	failed = (fd < 0);
	else
	failed = (fd != test->err);
	if (fd >= 0) {
	fdpath = fdreadlink(fd);
	close(fd);
	}

	if (failed) {
	resultfn = ksft_test_result_fail;

	ksft_print_msg("openat2 unexpectedly returned ");
	if (fdpath)
	ksft_print_msg("%d['%s']\n", fd, fdpath);
	else
	ksft_print_msg("%d (%s)\n", fd, strerror(-fd));
	}

	skip:
	if (test->err >= 0)
	resultfn("openat2 with %s argument [misalign=%d] succeeds\n",
	test->name, misalign);
	else
	resultfn("openat2 with %s argument [misalign=%d] fails with %d (%s)\n",
	test->name, misalign, test->err,
	strerror(-test->err));

	free(copy);
	free(fdpath);
	fflush(stdout);
	}
	}
	}

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

	#define NUM_OPENAT2_FLAG_TESTS 25

	void test_openat2_flags(void)
	{
	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 },
	};

	BUILD_BUG_ON(ARRAY_LEN(tests) != NUM_OPENAT2_FLAG_TESTS);

	for (int i = 0; i < ARRAY_LEN(tests); i++) {
	int fd, fdflags = -1;
	char path, fdpath = NULL;
	bool failed = false;
	struct flag_test *test = &tests[i];
	void (resultfn)(const char msg, ...) = ksft_test_result_pass;

	if (!openat2_supported) {
	ksft_print_msg("openat2(2) unsupported\n");
	resultfn = ksft_test_result_skip;
	goto skip;
	}

	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)
	*/
	ksft_test_result_skip("openat2 with %s fails with %d (%s)\n",
	test->name, fd, strerror(-fd));
	goto next;
	}

	if (test->err >= 0)
	failed = (fd < 0);
	else
	failed = (fd != test->err);
	if (fd >= 0) {
	int otherflags;

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

	E_assert(fdflags >= 0, "fcntl F_GETFL of new fd");
	E_assert(otherflags >= 0, "fcntl F_GETFD of new fd");

	/* 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;
	failed \|= (fdflags != test->how.flags);
	}

	if (failed) {
	resultfn = ksft_test_result_fail;

	ksft_print_msg("openat2 unexpectedly returned ");
	if (fdpath)
	ksft_print_msg("%d['%s'] with %X (!= %llX)\n",
	fd, fdpath, fdflags,
	test->how.flags);
	else
	ksft_print_msg("%d (%s)\n", fd, strerror(-fd));
	}

	skip:
	if (test->err >= 0)
	resultfn("openat2 with %s succeeds\n", test->name);
	else
	resultfn("openat2 with %s fails with %d (%s)\n",
	test->name, test->err, strerror(-test->err));
	next:
	free(fdpath);
	fflush(stdout);
	}
	}

	#define NUM_TESTS (NUM_OPENAT2_STRUCT_VARIATIONS * NUM_OPENAT2_STRUCT_TESTS + \
	NUM_OPENAT2_FLAG_TESTS)

	int main(int argc, char **argv)
	{
	ksft_print_header();
	ksft_set_plan(NUM_TESTS);

	test_openat2_struct();
	test_openat2_flags();

	if (ksft_get_fail_cnt() + ksft_get_error_cnt() > 0)
	ksft_exit_fail();
	else
	ksft_exit_pass();
	}