tools/testing/selftests/filesystems/openat2/openat2_test.c

// 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
#if defined(__aarch64__) || defined(__alpha__)
#define	O_LARGEFILE 0x20000
#elif defined(__powerpc__) || defined(__ppc__)
#define	O_LARGEFILE 0x10000
#elif defined(__sparc__)
#define O_LARGEFILE 0x40000
#elif defined(__mips__)
#define O_LARGEFILE 0x2000
#elif defined(__parisc__)
#define O_LARGEFILE 0x800
#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