| // 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(); | |
| } |