| // SPDX-License-Identifier: GPL-2.0 | |
| /* | |
| * selftest for the Ultravisor UAPI device | |
| * | |
| * Copyright IBM Corp. 2022 | |
| * Author(s): Steffen Eiden <seiden@linux.ibm.com> | |
| */ | |
| #include <stdint.h> | |
| #include <fcntl.h> | |
| #include <errno.h> | |
| #include <sys/ioctl.h> | |
| #include <sys/mman.h> | |
| #include <asm/uvdevice.h> | |
| #include "kselftest_harness.h" | |
| #define UV_PATH "/dev/uv" | |
| #define BUFFER_SIZE 0x200 | |
| FIXTURE(uvio_fixture) { | |
| int uv_fd; | |
| struct uvio_ioctl_cb uvio_ioctl; | |
| uint8_t buffer[BUFFER_SIZE]; | |
| __u64 fault_page; | |
| }; | |
| FIXTURE_VARIANT(uvio_fixture) { | |
| unsigned long ioctl_cmd; | |
| uint32_t arg_size; | |
| }; | |
| FIXTURE_VARIANT_ADD(uvio_fixture, att) { | |
| .ioctl_cmd = UVIO_IOCTL_ATT, | |
| .arg_size = sizeof(struct uvio_attest), | |
| }; | |
| FIXTURE_SETUP(uvio_fixture) | |
| { | |
| self->uv_fd = open(UV_PATH, O_ACCMODE); | |
| self->uvio_ioctl.argument_addr = (__u64)self->buffer; | |
| self->uvio_ioctl.argument_len = variant->arg_size; | |
| self->fault_page = | |
| (__u64)mmap(NULL, (size_t)getpagesize(), PROT_NONE, MAP_ANONYMOUS, -1, 0); | |
| } | |
| FIXTURE_TEARDOWN(uvio_fixture) | |
| { | |
| if (self->uv_fd) | |
| close(self->uv_fd); | |
| munmap((void *)self->fault_page, (size_t)getpagesize()); | |
| } | |
| TEST_F(uvio_fixture, fault_ioctl_arg) | |
| { | |
| int rc, errno_cache; | |
| rc = ioctl(self->uv_fd, variant->ioctl_cmd, NULL); | |
| errno_cache = errno; | |
| ASSERT_EQ(rc, -1); | |
| ASSERT_EQ(errno_cache, EFAULT); | |
| rc = ioctl(self->uv_fd, variant->ioctl_cmd, self->fault_page); | |
| errno_cache = errno; | |
| ASSERT_EQ(rc, -1); | |
| ASSERT_EQ(errno_cache, EFAULT); | |
| } | |
| TEST_F(uvio_fixture, fault_uvio_arg) | |
| { | |
| int rc, errno_cache; | |
| self->uvio_ioctl.argument_addr = 0; | |
| rc = ioctl(self->uv_fd, variant->ioctl_cmd, &self->uvio_ioctl); | |
| errno_cache = errno; | |
| ASSERT_EQ(rc, -1); | |
| ASSERT_EQ(errno_cache, EFAULT); | |
| self->uvio_ioctl.argument_addr = self->fault_page; | |
| rc = ioctl(self->uv_fd, variant->ioctl_cmd, &self->uvio_ioctl); | |
| errno_cache = errno; | |
| ASSERT_EQ(rc, -1); | |
| ASSERT_EQ(errno_cache, EFAULT); | |
| } | |
| /* | |
| * Test to verify that IOCTLs with invalid values in the ioctl_control block | |
| * are rejected. | |
| */ | |
| TEST_F(uvio_fixture, inval_ioctl_cb) | |
| { | |
| int rc, errno_cache; | |
| self->uvio_ioctl.argument_len = 0; | |
| rc = ioctl(self->uv_fd, variant->ioctl_cmd, &self->uvio_ioctl); | |
| errno_cache = errno; | |
| ASSERT_EQ(rc, -1); | |
| ASSERT_EQ(errno_cache, EINVAL); | |
| self->uvio_ioctl.argument_len = (uint32_t)-1; | |
| rc = ioctl(self->uv_fd, variant->ioctl_cmd, &self->uvio_ioctl); | |
| errno_cache = errno; | |
| ASSERT_EQ(rc, -1); | |
| ASSERT_EQ(errno_cache, EINVAL); | |
| self->uvio_ioctl.argument_len = variant->arg_size; | |
| self->uvio_ioctl.flags = (uint32_t)-1; | |
| rc = ioctl(self->uv_fd, variant->ioctl_cmd, &self->uvio_ioctl); | |
| errno_cache = errno; | |
| ASSERT_EQ(rc, -1); | |
| ASSERT_EQ(errno_cache, EINVAL); | |
| self->uvio_ioctl.flags = 0; | |
| memset(self->uvio_ioctl.reserved14, 0xff, sizeof(self->uvio_ioctl.reserved14)); | |
| rc = ioctl(self->uv_fd, variant->ioctl_cmd, &self->uvio_ioctl); | |
| errno_cache = errno; | |
| ASSERT_EQ(rc, -1); | |
| ASSERT_EQ(errno_cache, EINVAL); | |
| memset(&self->uvio_ioctl, 0x11, sizeof(self->uvio_ioctl)); | |
| rc = ioctl(self->uv_fd, variant->ioctl_cmd, &self->uvio_ioctl); | |
| ASSERT_EQ(rc, -1); | |
| } | |
| TEST_F(uvio_fixture, inval_ioctl_cmd) | |
| { | |
| int rc, errno_cache; | |
| uint8_t nr = _IOC_NR(variant->ioctl_cmd); | |
| unsigned long cmds[] = { | |
| _IOWR('a', nr, struct uvio_ioctl_cb), | |
| _IOWR(UVIO_TYPE_UVC, nr, int), | |
| _IO(UVIO_TYPE_UVC, nr), | |
| _IOR(UVIO_TYPE_UVC, nr, struct uvio_ioctl_cb), | |
| _IOW(UVIO_TYPE_UVC, nr, struct uvio_ioctl_cb), | |
| }; | |
| for (size_t i = 0; i < ARRAY_SIZE(cmds); i++) { | |
| rc = ioctl(self->uv_fd, cmds[i], &self->uvio_ioctl); | |
| errno_cache = errno; | |
| ASSERT_EQ(rc, -1); | |
| ASSERT_EQ(errno_cache, ENOTTY); | |
| } | |
| } | |
| struct test_attest_buffer { | |
| uint8_t arcb[0x180]; | |
| uint8_t meas[64]; | |
| uint8_t add[32]; | |
| }; | |
| FIXTURE(attest_fixture) { | |
| int uv_fd; | |
| struct uvio_ioctl_cb uvio_ioctl; | |
| struct uvio_attest uvio_attest; | |
| struct test_attest_buffer attest_buffer; | |
| __u64 fault_page; | |
| }; | |
| FIXTURE_SETUP(attest_fixture) | |
| { | |
| self->uv_fd = open(UV_PATH, O_ACCMODE); | |
| self->uvio_ioctl.argument_addr = (__u64)&self->uvio_attest; | |
| self->uvio_ioctl.argument_len = sizeof(self->uvio_attest); | |
| self->uvio_attest.arcb_addr = (__u64)&self->attest_buffer.arcb; | |
| self->uvio_attest.arcb_len = sizeof(self->attest_buffer.arcb); | |
| self->uvio_attest.meas_addr = (__u64)&self->attest_buffer.meas; | |
| self->uvio_attest.meas_len = sizeof(self->attest_buffer.meas); | |
| self->uvio_attest.add_data_addr = (__u64)&self->attest_buffer.add; | |
| self->uvio_attest.add_data_len = sizeof(self->attest_buffer.add); | |
| self->fault_page = | |
| (__u64)mmap(NULL, (size_t)getpagesize(), PROT_NONE, MAP_ANONYMOUS, -1, 0); | |
| } | |
| FIXTURE_TEARDOWN(attest_fixture) | |
| { | |
| if (self->uv_fd) | |
| close(self->uv_fd); | |
| munmap((void *)self->fault_page, (size_t)getpagesize()); | |
| } | |
| static void att_inval_sizes_test(uint32_t *size, uint32_t max_size, bool test_zero, | |
| struct __test_metadata *_metadata, | |
| FIXTURE_DATA(attest_fixture) *self) | |
| { | |
| int rc, errno_cache; | |
| uint32_t tmp = *size; | |
| if (test_zero) { | |
| *size = 0; | |
| rc = ioctl(self->uv_fd, UVIO_IOCTL_ATT, &self->uvio_ioctl); | |
| errno_cache = errno; | |
| ASSERT_EQ(rc, -1); | |
| ASSERT_EQ(errno_cache, EINVAL); | |
| } | |
| *size = max_size + 1; | |
| rc = ioctl(self->uv_fd, UVIO_IOCTL_ATT, &self->uvio_ioctl); | |
| errno_cache = errno; | |
| ASSERT_EQ(rc, -1); | |
| ASSERT_EQ(errno_cache, EINVAL); | |
| *size = tmp; | |
| } | |
| /* | |
| * Test to verify that attestation IOCTLs with invalid values in the UVIO | |
| * attestation control block are rejected. | |
| */ | |
| TEST_F(attest_fixture, att_inval_request) | |
| { | |
| int rc, errno_cache; | |
| att_inval_sizes_test(&self->uvio_attest.add_data_len, UVIO_ATT_ADDITIONAL_MAX_LEN, | |
| false, _metadata, self); | |
| att_inval_sizes_test(&self->uvio_attest.meas_len, UVIO_ATT_MEASUREMENT_MAX_LEN, | |
| true, _metadata, self); | |
| att_inval_sizes_test(&self->uvio_attest.arcb_len, UVIO_ATT_ARCB_MAX_LEN, | |
| true, _metadata, self); | |
| self->uvio_attest.reserved136 = (uint16_t)-1; | |
| rc = ioctl(self->uv_fd, UVIO_IOCTL_ATT, &self->uvio_ioctl); | |
| errno_cache = errno; | |
| ASSERT_EQ(rc, -1); | |
| ASSERT_EQ(errno_cache, EINVAL); | |
| memset(&self->uvio_attest, 0x11, sizeof(self->uvio_attest)); | |
| rc = ioctl(self->uv_fd, UVIO_IOCTL_ATT, &self->uvio_ioctl); | |
| ASSERT_EQ(rc, -1); | |
| } | |
| static void att_inval_addr_test(__u64 *addr, struct __test_metadata *_metadata, | |
| FIXTURE_DATA(attest_fixture) *self) | |
| { | |
| int rc, errno_cache; | |
| __u64 tmp = *addr; | |
| *addr = 0; | |
| rc = ioctl(self->uv_fd, UVIO_IOCTL_ATT, &self->uvio_ioctl); | |
| errno_cache = errno; | |
| ASSERT_EQ(rc, -1); | |
| ASSERT_EQ(errno_cache, EFAULT); | |
| *addr = self->fault_page; | |
| rc = ioctl(self->uv_fd, UVIO_IOCTL_ATT, &self->uvio_ioctl); | |
| errno_cache = errno; | |
| ASSERT_EQ(rc, -1); | |
| ASSERT_EQ(errno_cache, EFAULT); | |
| *addr = tmp; | |
| } | |
| TEST_F(attest_fixture, att_inval_addr) | |
| { | |
| att_inval_addr_test(&self->uvio_attest.arcb_addr, _metadata, self); | |
| att_inval_addr_test(&self->uvio_attest.add_data_addr, _metadata, self); | |
| att_inval_addr_test(&self->uvio_attest.meas_addr, _metadata, self); | |
| } | |
| int main(int argc, char **argv) | |
| { | |
| int fd = open(UV_PATH, O_ACCMODE); | |
| if (fd < 0) | |
| ksft_exit_skip("No uv-device or cannot access " UV_PATH "\n" | |
| "Enable CONFIG_S390_UV_UAPI and check the access rights on " | |
| UV_PATH ".\n"); | |
| close(fd); | |
| return test_harness_run(argc, argv); | |
| } |