mirror of
https://github.com/torvalds/linux.git
synced 2024-12-05 10:32:35 +00:00
407fc184f0
Rework the functions that test and set the bitmaps to receive a new parameter (the pte_page_size) that reflects the expected PTE size in the page tables. The same scheme is still used i.e. even bits are dirty and odd page indexes aren't dirty. Here it just refactors to consider the size of the PTE rather than hardcoded to IOMMU mock base page assumptions. While at it, refactor dirty bitmap tests to use the idev_id created by the fixture instead of creating a new one. This is in preparation for doing tests with IOMMU hugepages where multiple bits set as part of recording a whole hugepage as dirty and thus the pte_page_size will vary depending on io hugepages or io base pages. Link: https://lore.kernel.org/r/20240202133415.23819-6-joao.m.martins@oracle.com Signed-off-by: Joao Martins <joao.m.martins@oracle.com> Signed-off-by: Jason Gunthorpe <jgg@nvidia.com>
687 lines
22 KiB
C
687 lines
22 KiB
C
/* SPDX-License-Identifier: GPL-2.0-only */
|
|
/* Copyright (c) 2021-2022, NVIDIA CORPORATION & AFFILIATES */
|
|
#ifndef __SELFTEST_IOMMUFD_UTILS
|
|
#define __SELFTEST_IOMMUFD_UTILS
|
|
|
|
#include <unistd.h>
|
|
#include <stddef.h>
|
|
#include <sys/fcntl.h>
|
|
#include <sys/ioctl.h>
|
|
#include <stdint.h>
|
|
#include <assert.h>
|
|
|
|
#include "../kselftest_harness.h"
|
|
#include "../../../../drivers/iommu/iommufd/iommufd_test.h"
|
|
|
|
/* Hack to make assertions more readable */
|
|
#define _IOMMU_TEST_CMD(x) IOMMU_TEST_CMD
|
|
|
|
/* Imported from include/asm-generic/bitops/generic-non-atomic.h */
|
|
#define BITS_PER_BYTE 8
|
|
#define BITS_PER_LONG __BITS_PER_LONG
|
|
#define BIT_MASK(nr) (1UL << ((nr) % __BITS_PER_LONG))
|
|
#define BIT_WORD(nr) ((nr) / __BITS_PER_LONG)
|
|
|
|
static inline void set_bit(unsigned int nr, unsigned long *addr)
|
|
{
|
|
unsigned long mask = BIT_MASK(nr);
|
|
unsigned long *p = ((unsigned long *)addr) + BIT_WORD(nr);
|
|
|
|
*p |= mask;
|
|
}
|
|
|
|
static inline bool test_bit(unsigned int nr, unsigned long *addr)
|
|
{
|
|
return 1UL & (addr[BIT_WORD(nr)] >> (nr & (BITS_PER_LONG - 1)));
|
|
}
|
|
|
|
static void *buffer;
|
|
static unsigned long BUFFER_SIZE;
|
|
|
|
static unsigned long PAGE_SIZE;
|
|
|
|
#define sizeof_field(TYPE, MEMBER) sizeof((((TYPE *)0)->MEMBER))
|
|
#define offsetofend(TYPE, MEMBER) \
|
|
(offsetof(TYPE, MEMBER) + sizeof_field(TYPE, MEMBER))
|
|
|
|
/*
|
|
* Have the kernel check the refcount on pages. I don't know why a freshly
|
|
* mmap'd anon non-compound page starts out with a ref of 3
|
|
*/
|
|
#define check_refs(_ptr, _length, _refs) \
|
|
({ \
|
|
struct iommu_test_cmd test_cmd = { \
|
|
.size = sizeof(test_cmd), \
|
|
.op = IOMMU_TEST_OP_MD_CHECK_REFS, \
|
|
.check_refs = { .length = _length, \
|
|
.uptr = (uintptr_t)(_ptr), \
|
|
.refs = _refs }, \
|
|
}; \
|
|
ASSERT_EQ(0, \
|
|
ioctl(self->fd, \
|
|
_IOMMU_TEST_CMD(IOMMU_TEST_OP_MD_CHECK_REFS), \
|
|
&test_cmd)); \
|
|
})
|
|
|
|
static int _test_cmd_mock_domain(int fd, unsigned int ioas_id, __u32 *stdev_id,
|
|
__u32 *hwpt_id, __u32 *idev_id)
|
|
{
|
|
struct iommu_test_cmd cmd = {
|
|
.size = sizeof(cmd),
|
|
.op = IOMMU_TEST_OP_MOCK_DOMAIN,
|
|
.id = ioas_id,
|
|
.mock_domain = {},
|
|
};
|
|
int ret;
|
|
|
|
ret = ioctl(fd, IOMMU_TEST_CMD, &cmd);
|
|
if (ret)
|
|
return ret;
|
|
if (stdev_id)
|
|
*stdev_id = cmd.mock_domain.out_stdev_id;
|
|
assert(cmd.id != 0);
|
|
if (hwpt_id)
|
|
*hwpt_id = cmd.mock_domain.out_hwpt_id;
|
|
if (idev_id)
|
|
*idev_id = cmd.mock_domain.out_idev_id;
|
|
return 0;
|
|
}
|
|
#define test_cmd_mock_domain(ioas_id, stdev_id, hwpt_id, idev_id) \
|
|
ASSERT_EQ(0, _test_cmd_mock_domain(self->fd, ioas_id, stdev_id, \
|
|
hwpt_id, idev_id))
|
|
#define test_err_mock_domain(_errno, ioas_id, stdev_id, hwpt_id) \
|
|
EXPECT_ERRNO(_errno, _test_cmd_mock_domain(self->fd, ioas_id, \
|
|
stdev_id, hwpt_id, NULL))
|
|
|
|
static int _test_cmd_mock_domain_flags(int fd, unsigned int ioas_id,
|
|
__u32 stdev_flags, __u32 *stdev_id,
|
|
__u32 *hwpt_id, __u32 *idev_id)
|
|
{
|
|
struct iommu_test_cmd cmd = {
|
|
.size = sizeof(cmd),
|
|
.op = IOMMU_TEST_OP_MOCK_DOMAIN_FLAGS,
|
|
.id = ioas_id,
|
|
.mock_domain_flags = { .dev_flags = stdev_flags },
|
|
};
|
|
int ret;
|
|
|
|
ret = ioctl(fd, IOMMU_TEST_CMD, &cmd);
|
|
if (ret)
|
|
return ret;
|
|
if (stdev_id)
|
|
*stdev_id = cmd.mock_domain_flags.out_stdev_id;
|
|
assert(cmd.id != 0);
|
|
if (hwpt_id)
|
|
*hwpt_id = cmd.mock_domain_flags.out_hwpt_id;
|
|
if (idev_id)
|
|
*idev_id = cmd.mock_domain_flags.out_idev_id;
|
|
return 0;
|
|
}
|
|
#define test_cmd_mock_domain_flags(ioas_id, flags, stdev_id, hwpt_id, idev_id) \
|
|
ASSERT_EQ(0, _test_cmd_mock_domain_flags(self->fd, ioas_id, flags, \
|
|
stdev_id, hwpt_id, idev_id))
|
|
#define test_err_mock_domain_flags(_errno, ioas_id, flags, stdev_id, hwpt_id) \
|
|
EXPECT_ERRNO(_errno, \
|
|
_test_cmd_mock_domain_flags(self->fd, ioas_id, flags, \
|
|
stdev_id, hwpt_id, NULL))
|
|
|
|
static int _test_cmd_mock_domain_replace(int fd, __u32 stdev_id, __u32 pt_id,
|
|
__u32 *hwpt_id)
|
|
{
|
|
struct iommu_test_cmd cmd = {
|
|
.size = sizeof(cmd),
|
|
.op = IOMMU_TEST_OP_MOCK_DOMAIN_REPLACE,
|
|
.id = stdev_id,
|
|
.mock_domain_replace = {
|
|
.pt_id = pt_id,
|
|
},
|
|
};
|
|
int ret;
|
|
|
|
ret = ioctl(fd, IOMMU_TEST_CMD, &cmd);
|
|
if (ret)
|
|
return ret;
|
|
if (hwpt_id)
|
|
*hwpt_id = cmd.mock_domain_replace.pt_id;
|
|
return 0;
|
|
}
|
|
|
|
#define test_cmd_mock_domain_replace(stdev_id, pt_id) \
|
|
ASSERT_EQ(0, _test_cmd_mock_domain_replace(self->fd, stdev_id, pt_id, \
|
|
NULL))
|
|
#define test_err_mock_domain_replace(_errno, stdev_id, pt_id) \
|
|
EXPECT_ERRNO(_errno, _test_cmd_mock_domain_replace(self->fd, stdev_id, \
|
|
pt_id, NULL))
|
|
|
|
static int _test_cmd_hwpt_alloc(int fd, __u32 device_id, __u32 pt_id,
|
|
__u32 flags, __u32 *hwpt_id, __u32 data_type,
|
|
void *data, size_t data_len)
|
|
{
|
|
struct iommu_hwpt_alloc cmd = {
|
|
.size = sizeof(cmd),
|
|
.flags = flags,
|
|
.dev_id = device_id,
|
|
.pt_id = pt_id,
|
|
.data_type = data_type,
|
|
.data_len = data_len,
|
|
.data_uptr = (uint64_t)data,
|
|
};
|
|
int ret;
|
|
|
|
ret = ioctl(fd, IOMMU_HWPT_ALLOC, &cmd);
|
|
if (ret)
|
|
return ret;
|
|
if (hwpt_id)
|
|
*hwpt_id = cmd.out_hwpt_id;
|
|
return 0;
|
|
}
|
|
|
|
#define test_cmd_hwpt_alloc(device_id, pt_id, flags, hwpt_id) \
|
|
ASSERT_EQ(0, _test_cmd_hwpt_alloc(self->fd, device_id, pt_id, flags, \
|
|
hwpt_id, IOMMU_HWPT_DATA_NONE, NULL, \
|
|
0))
|
|
#define test_err_hwpt_alloc(_errno, device_id, pt_id, flags, hwpt_id) \
|
|
EXPECT_ERRNO(_errno, _test_cmd_hwpt_alloc( \
|
|
self->fd, device_id, pt_id, flags, \
|
|
hwpt_id, IOMMU_HWPT_DATA_NONE, NULL, 0))
|
|
|
|
#define test_cmd_hwpt_alloc_nested(device_id, pt_id, flags, hwpt_id, \
|
|
data_type, data, data_len) \
|
|
ASSERT_EQ(0, _test_cmd_hwpt_alloc(self->fd, device_id, pt_id, flags, \
|
|
hwpt_id, data_type, data, data_len))
|
|
#define test_err_hwpt_alloc_nested(_errno, device_id, pt_id, flags, hwpt_id, \
|
|
data_type, data, data_len) \
|
|
EXPECT_ERRNO(_errno, \
|
|
_test_cmd_hwpt_alloc(self->fd, device_id, pt_id, flags, \
|
|
hwpt_id, data_type, data, data_len))
|
|
|
|
#define test_cmd_hwpt_check_iotlb(hwpt_id, iotlb_id, expected) \
|
|
({ \
|
|
struct iommu_test_cmd test_cmd = { \
|
|
.size = sizeof(test_cmd), \
|
|
.op = IOMMU_TEST_OP_MD_CHECK_IOTLB, \
|
|
.id = hwpt_id, \
|
|
.check_iotlb = { \
|
|
.id = iotlb_id, \
|
|
.iotlb = expected, \
|
|
}, \
|
|
}; \
|
|
ASSERT_EQ(0, \
|
|
ioctl(self->fd, \
|
|
_IOMMU_TEST_CMD(IOMMU_TEST_OP_MD_CHECK_IOTLB), \
|
|
&test_cmd)); \
|
|
})
|
|
|
|
#define test_cmd_hwpt_check_iotlb_all(hwpt_id, expected) \
|
|
({ \
|
|
int i; \
|
|
for (i = 0; i < MOCK_NESTED_DOMAIN_IOTLB_NUM; i++) \
|
|
test_cmd_hwpt_check_iotlb(hwpt_id, i, expected); \
|
|
})
|
|
|
|
static int _test_cmd_hwpt_invalidate(int fd, __u32 hwpt_id, void *reqs,
|
|
uint32_t data_type, uint32_t lreq,
|
|
uint32_t *nreqs)
|
|
{
|
|
struct iommu_hwpt_invalidate cmd = {
|
|
.size = sizeof(cmd),
|
|
.hwpt_id = hwpt_id,
|
|
.data_type = data_type,
|
|
.data_uptr = (uint64_t)reqs,
|
|
.entry_len = lreq,
|
|
.entry_num = *nreqs,
|
|
};
|
|
int rc = ioctl(fd, IOMMU_HWPT_INVALIDATE, &cmd);
|
|
*nreqs = cmd.entry_num;
|
|
return rc;
|
|
}
|
|
|
|
#define test_cmd_hwpt_invalidate(hwpt_id, reqs, data_type, lreq, nreqs) \
|
|
({ \
|
|
ASSERT_EQ(0, \
|
|
_test_cmd_hwpt_invalidate(self->fd, hwpt_id, reqs, \
|
|
data_type, lreq, nreqs)); \
|
|
})
|
|
#define test_err_hwpt_invalidate(_errno, hwpt_id, reqs, data_type, lreq, \
|
|
nreqs) \
|
|
({ \
|
|
EXPECT_ERRNO(_errno, _test_cmd_hwpt_invalidate( \
|
|
self->fd, hwpt_id, reqs, \
|
|
data_type, lreq, nreqs)); \
|
|
})
|
|
|
|
static int _test_cmd_access_replace_ioas(int fd, __u32 access_id,
|
|
unsigned int ioas_id)
|
|
{
|
|
struct iommu_test_cmd cmd = {
|
|
.size = sizeof(cmd),
|
|
.op = IOMMU_TEST_OP_ACCESS_REPLACE_IOAS,
|
|
.id = access_id,
|
|
.access_replace_ioas = { .ioas_id = ioas_id },
|
|
};
|
|
int ret;
|
|
|
|
ret = ioctl(fd, IOMMU_TEST_CMD, &cmd);
|
|
if (ret)
|
|
return ret;
|
|
return 0;
|
|
}
|
|
#define test_cmd_access_replace_ioas(access_id, ioas_id) \
|
|
ASSERT_EQ(0, _test_cmd_access_replace_ioas(self->fd, access_id, ioas_id))
|
|
|
|
static int _test_cmd_set_dirty_tracking(int fd, __u32 hwpt_id, bool enabled)
|
|
{
|
|
struct iommu_hwpt_set_dirty_tracking cmd = {
|
|
.size = sizeof(cmd),
|
|
.flags = enabled ? IOMMU_HWPT_DIRTY_TRACKING_ENABLE : 0,
|
|
.hwpt_id = hwpt_id,
|
|
};
|
|
int ret;
|
|
|
|
ret = ioctl(fd, IOMMU_HWPT_SET_DIRTY_TRACKING, &cmd);
|
|
if (ret)
|
|
return -errno;
|
|
return 0;
|
|
}
|
|
#define test_cmd_set_dirty_tracking(hwpt_id, enabled) \
|
|
ASSERT_EQ(0, _test_cmd_set_dirty_tracking(self->fd, hwpt_id, enabled))
|
|
|
|
static int _test_cmd_get_dirty_bitmap(int fd, __u32 hwpt_id, size_t length,
|
|
__u64 iova, size_t page_size,
|
|
__u64 *bitmap, __u32 flags)
|
|
{
|
|
struct iommu_hwpt_get_dirty_bitmap cmd = {
|
|
.size = sizeof(cmd),
|
|
.hwpt_id = hwpt_id,
|
|
.flags = flags,
|
|
.iova = iova,
|
|
.length = length,
|
|
.page_size = page_size,
|
|
.data = (uintptr_t)bitmap,
|
|
};
|
|
int ret;
|
|
|
|
ret = ioctl(fd, IOMMU_HWPT_GET_DIRTY_BITMAP, &cmd);
|
|
if (ret)
|
|
return ret;
|
|
return 0;
|
|
}
|
|
|
|
#define test_cmd_get_dirty_bitmap(fd, hwpt_id, length, iova, page_size, \
|
|
bitmap, flags) \
|
|
ASSERT_EQ(0, _test_cmd_get_dirty_bitmap(fd, hwpt_id, length, iova, \
|
|
page_size, bitmap, flags))
|
|
|
|
static int _test_cmd_mock_domain_set_dirty(int fd, __u32 hwpt_id, size_t length,
|
|
__u64 iova, size_t page_size,
|
|
__u64 *bitmap, __u64 *dirty)
|
|
{
|
|
struct iommu_test_cmd cmd = {
|
|
.size = sizeof(cmd),
|
|
.op = IOMMU_TEST_OP_DIRTY,
|
|
.id = hwpt_id,
|
|
.dirty = {
|
|
.iova = iova,
|
|
.length = length,
|
|
.page_size = page_size,
|
|
.uptr = (uintptr_t)bitmap,
|
|
}
|
|
};
|
|
int ret;
|
|
|
|
ret = ioctl(fd, _IOMMU_TEST_CMD(IOMMU_TEST_OP_DIRTY), &cmd);
|
|
if (ret)
|
|
return -ret;
|
|
if (dirty)
|
|
*dirty = cmd.dirty.out_nr_dirty;
|
|
return 0;
|
|
}
|
|
|
|
#define test_cmd_mock_domain_set_dirty(fd, hwpt_id, length, iova, page_size, \
|
|
bitmap, nr) \
|
|
ASSERT_EQ(0, \
|
|
_test_cmd_mock_domain_set_dirty(fd, hwpt_id, length, iova, \
|
|
page_size, bitmap, nr))
|
|
|
|
static int _test_mock_dirty_bitmaps(int fd, __u32 hwpt_id, size_t length,
|
|
__u64 iova, size_t page_size,
|
|
size_t pte_page_size, __u64 *bitmap,
|
|
__u64 bitmap_size, __u32 flags,
|
|
struct __test_metadata *_metadata)
|
|
{
|
|
unsigned long npte = pte_page_size / page_size, pteset = 2 * npte;
|
|
unsigned long nbits = bitmap_size * BITS_PER_BYTE;
|
|
unsigned long j, i, nr = nbits / pteset ?: 1;
|
|
__u64 out_dirty = 0;
|
|
|
|
/* Mark all even bits as dirty in the mock domain */
|
|
memset(bitmap, 0, bitmap_size);
|
|
for (i = 0; i < nbits; i += pteset)
|
|
set_bit(i, (unsigned long *)bitmap);
|
|
|
|
test_cmd_mock_domain_set_dirty(fd, hwpt_id, length, iova, page_size,
|
|
bitmap, &out_dirty);
|
|
ASSERT_EQ(nr, out_dirty);
|
|
|
|
/* Expect all even bits as dirty in the user bitmap */
|
|
memset(bitmap, 0, bitmap_size);
|
|
test_cmd_get_dirty_bitmap(fd, hwpt_id, length, iova, page_size, bitmap,
|
|
flags);
|
|
/* Beware ASSERT_EQ() is two statements -- braces are not redundant! */
|
|
for (i = 0; i < nbits; i += pteset) {
|
|
for (j = 0; j < pteset; j++) {
|
|
ASSERT_EQ(j < npte,
|
|
test_bit(i + j, (unsigned long *)bitmap));
|
|
}
|
|
ASSERT_EQ(!(i % pteset), test_bit(i, (unsigned long *)bitmap));
|
|
}
|
|
|
|
memset(bitmap, 0, bitmap_size);
|
|
test_cmd_get_dirty_bitmap(fd, hwpt_id, length, iova, page_size, bitmap,
|
|
flags);
|
|
|
|
/* It as read already -- expect all zeroes */
|
|
for (i = 0; i < nbits; i += pteset) {
|
|
for (j = 0; j < pteset; j++) {
|
|
ASSERT_EQ(
|
|
(j < npte) &&
|
|
(flags &
|
|
IOMMU_HWPT_GET_DIRTY_BITMAP_NO_CLEAR),
|
|
test_bit(i + j, (unsigned long *)bitmap));
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
#define test_mock_dirty_bitmaps(hwpt_id, length, iova, page_size, pte_size,\
|
|
bitmap, bitmap_size, flags, _metadata) \
|
|
ASSERT_EQ(0, _test_mock_dirty_bitmaps(self->fd, hwpt_id, length, iova, \
|
|
page_size, pte_size, bitmap, \
|
|
bitmap_size, flags, _metadata))
|
|
|
|
static int _test_cmd_create_access(int fd, unsigned int ioas_id,
|
|
__u32 *access_id, unsigned int flags)
|
|
{
|
|
struct iommu_test_cmd cmd = {
|
|
.size = sizeof(cmd),
|
|
.op = IOMMU_TEST_OP_CREATE_ACCESS,
|
|
.id = ioas_id,
|
|
.create_access = { .flags = flags },
|
|
};
|
|
int ret;
|
|
|
|
ret = ioctl(fd, IOMMU_TEST_CMD, &cmd);
|
|
if (ret)
|
|
return ret;
|
|
*access_id = cmd.create_access.out_access_fd;
|
|
return 0;
|
|
}
|
|
#define test_cmd_create_access(ioas_id, access_id, flags) \
|
|
ASSERT_EQ(0, _test_cmd_create_access(self->fd, ioas_id, access_id, \
|
|
flags))
|
|
|
|
static int _test_cmd_destroy_access(unsigned int access_id)
|
|
{
|
|
return close(access_id);
|
|
}
|
|
#define test_cmd_destroy_access(access_id) \
|
|
ASSERT_EQ(0, _test_cmd_destroy_access(access_id))
|
|
|
|
static int _test_cmd_destroy_access_pages(int fd, unsigned int access_id,
|
|
unsigned int access_pages_id)
|
|
{
|
|
struct iommu_test_cmd cmd = {
|
|
.size = sizeof(cmd),
|
|
.op = IOMMU_TEST_OP_DESTROY_ACCESS_PAGES,
|
|
.id = access_id,
|
|
.destroy_access_pages = { .access_pages_id = access_pages_id },
|
|
};
|
|
return ioctl(fd, IOMMU_TEST_CMD, &cmd);
|
|
}
|
|
#define test_cmd_destroy_access_pages(access_id, access_pages_id) \
|
|
ASSERT_EQ(0, _test_cmd_destroy_access_pages(self->fd, access_id, \
|
|
access_pages_id))
|
|
#define test_err_destroy_access_pages(_errno, access_id, access_pages_id) \
|
|
EXPECT_ERRNO(_errno, _test_cmd_destroy_access_pages( \
|
|
self->fd, access_id, access_pages_id))
|
|
|
|
static int _test_ioctl_destroy(int fd, unsigned int id)
|
|
{
|
|
struct iommu_destroy cmd = {
|
|
.size = sizeof(cmd),
|
|
.id = id,
|
|
};
|
|
return ioctl(fd, IOMMU_DESTROY, &cmd);
|
|
}
|
|
#define test_ioctl_destroy(id) ASSERT_EQ(0, _test_ioctl_destroy(self->fd, id))
|
|
|
|
static int _test_ioctl_ioas_alloc(int fd, __u32 *id)
|
|
{
|
|
struct iommu_ioas_alloc cmd = {
|
|
.size = sizeof(cmd),
|
|
};
|
|
int ret;
|
|
|
|
ret = ioctl(fd, IOMMU_IOAS_ALLOC, &cmd);
|
|
if (ret)
|
|
return ret;
|
|
*id = cmd.out_ioas_id;
|
|
return 0;
|
|
}
|
|
#define test_ioctl_ioas_alloc(id) \
|
|
({ \
|
|
ASSERT_EQ(0, _test_ioctl_ioas_alloc(self->fd, id)); \
|
|
ASSERT_NE(0, *(id)); \
|
|
})
|
|
|
|
static int _test_ioctl_ioas_map(int fd, unsigned int ioas_id, void *buffer,
|
|
size_t length, __u64 *iova, unsigned int flags)
|
|
{
|
|
struct iommu_ioas_map cmd = {
|
|
.size = sizeof(cmd),
|
|
.flags = flags,
|
|
.ioas_id = ioas_id,
|
|
.user_va = (uintptr_t)buffer,
|
|
.length = length,
|
|
};
|
|
int ret;
|
|
|
|
if (flags & IOMMU_IOAS_MAP_FIXED_IOVA)
|
|
cmd.iova = *iova;
|
|
|
|
ret = ioctl(fd, IOMMU_IOAS_MAP, &cmd);
|
|
*iova = cmd.iova;
|
|
return ret;
|
|
}
|
|
#define test_ioctl_ioas_map(buffer, length, iova_p) \
|
|
ASSERT_EQ(0, _test_ioctl_ioas_map(self->fd, self->ioas_id, buffer, \
|
|
length, iova_p, \
|
|
IOMMU_IOAS_MAP_WRITEABLE | \
|
|
IOMMU_IOAS_MAP_READABLE))
|
|
|
|
#define test_err_ioctl_ioas_map(_errno, buffer, length, iova_p) \
|
|
EXPECT_ERRNO(_errno, \
|
|
_test_ioctl_ioas_map(self->fd, self->ioas_id, buffer, \
|
|
length, iova_p, \
|
|
IOMMU_IOAS_MAP_WRITEABLE | \
|
|
IOMMU_IOAS_MAP_READABLE))
|
|
|
|
#define test_ioctl_ioas_map_id(ioas_id, buffer, length, iova_p) \
|
|
ASSERT_EQ(0, _test_ioctl_ioas_map(self->fd, ioas_id, buffer, length, \
|
|
iova_p, \
|
|
IOMMU_IOAS_MAP_WRITEABLE | \
|
|
IOMMU_IOAS_MAP_READABLE))
|
|
|
|
#define test_ioctl_ioas_map_fixed(buffer, length, iova) \
|
|
({ \
|
|
__u64 __iova = iova; \
|
|
ASSERT_EQ(0, _test_ioctl_ioas_map( \
|
|
self->fd, self->ioas_id, buffer, length, \
|
|
&__iova, \
|
|
IOMMU_IOAS_MAP_FIXED_IOVA | \
|
|
IOMMU_IOAS_MAP_WRITEABLE | \
|
|
IOMMU_IOAS_MAP_READABLE)); \
|
|
})
|
|
|
|
#define test_ioctl_ioas_map_fixed_id(ioas_id, buffer, length, iova) \
|
|
({ \
|
|
__u64 __iova = iova; \
|
|
ASSERT_EQ(0, \
|
|
_test_ioctl_ioas_map( \
|
|
self->fd, ioas_id, buffer, length, &__iova, \
|
|
IOMMU_IOAS_MAP_FIXED_IOVA | \
|
|
IOMMU_IOAS_MAP_WRITEABLE | \
|
|
IOMMU_IOAS_MAP_READABLE)); \
|
|
})
|
|
|
|
#define test_err_ioctl_ioas_map_fixed(_errno, buffer, length, iova) \
|
|
({ \
|
|
__u64 __iova = iova; \
|
|
EXPECT_ERRNO(_errno, \
|
|
_test_ioctl_ioas_map( \
|
|
self->fd, self->ioas_id, buffer, length, \
|
|
&__iova, \
|
|
IOMMU_IOAS_MAP_FIXED_IOVA | \
|
|
IOMMU_IOAS_MAP_WRITEABLE | \
|
|
IOMMU_IOAS_MAP_READABLE)); \
|
|
})
|
|
|
|
static int _test_ioctl_ioas_unmap(int fd, unsigned int ioas_id, uint64_t iova,
|
|
size_t length, uint64_t *out_len)
|
|
{
|
|
struct iommu_ioas_unmap cmd = {
|
|
.size = sizeof(cmd),
|
|
.ioas_id = ioas_id,
|
|
.iova = iova,
|
|
.length = length,
|
|
};
|
|
int ret;
|
|
|
|
ret = ioctl(fd, IOMMU_IOAS_UNMAP, &cmd);
|
|
if (out_len)
|
|
*out_len = cmd.length;
|
|
return ret;
|
|
}
|
|
#define test_ioctl_ioas_unmap(iova, length) \
|
|
ASSERT_EQ(0, _test_ioctl_ioas_unmap(self->fd, self->ioas_id, iova, \
|
|
length, NULL))
|
|
|
|
#define test_ioctl_ioas_unmap_id(ioas_id, iova, length) \
|
|
ASSERT_EQ(0, _test_ioctl_ioas_unmap(self->fd, ioas_id, iova, length, \
|
|
NULL))
|
|
|
|
#define test_err_ioctl_ioas_unmap(_errno, iova, length) \
|
|
EXPECT_ERRNO(_errno, _test_ioctl_ioas_unmap(self->fd, self->ioas_id, \
|
|
iova, length, NULL))
|
|
|
|
static int _test_ioctl_set_temp_memory_limit(int fd, unsigned int limit)
|
|
{
|
|
struct iommu_test_cmd memlimit_cmd = {
|
|
.size = sizeof(memlimit_cmd),
|
|
.op = IOMMU_TEST_OP_SET_TEMP_MEMORY_LIMIT,
|
|
.memory_limit = { .limit = limit },
|
|
};
|
|
|
|
return ioctl(fd, _IOMMU_TEST_CMD(IOMMU_TEST_OP_SET_TEMP_MEMORY_LIMIT),
|
|
&memlimit_cmd);
|
|
}
|
|
|
|
#define test_ioctl_set_temp_memory_limit(limit) \
|
|
ASSERT_EQ(0, _test_ioctl_set_temp_memory_limit(self->fd, limit))
|
|
|
|
#define test_ioctl_set_default_memory_limit() \
|
|
test_ioctl_set_temp_memory_limit(65536)
|
|
|
|
static void teardown_iommufd(int fd, struct __test_metadata *_metadata)
|
|
{
|
|
struct iommu_test_cmd test_cmd = {
|
|
.size = sizeof(test_cmd),
|
|
.op = IOMMU_TEST_OP_MD_CHECK_REFS,
|
|
.check_refs = { .length = BUFFER_SIZE,
|
|
.uptr = (uintptr_t)buffer },
|
|
};
|
|
|
|
if (fd == -1)
|
|
return;
|
|
|
|
EXPECT_EQ(0, close(fd));
|
|
|
|
fd = open("/dev/iommu", O_RDWR);
|
|
EXPECT_NE(-1, fd);
|
|
EXPECT_EQ(0, ioctl(fd, _IOMMU_TEST_CMD(IOMMU_TEST_OP_MD_CHECK_REFS),
|
|
&test_cmd));
|
|
EXPECT_EQ(0, close(fd));
|
|
}
|
|
|
|
#define EXPECT_ERRNO(expected_errno, cmd) \
|
|
({ \
|
|
ASSERT_EQ(-1, cmd); \
|
|
EXPECT_EQ(expected_errno, errno); \
|
|
})
|
|
|
|
#endif
|
|
|
|
/* @data can be NULL */
|
|
static int _test_cmd_get_hw_info(int fd, __u32 device_id, void *data,
|
|
size_t data_len, uint32_t *capabilities)
|
|
{
|
|
struct iommu_test_hw_info *info = (struct iommu_test_hw_info *)data;
|
|
struct iommu_hw_info cmd = {
|
|
.size = sizeof(cmd),
|
|
.dev_id = device_id,
|
|
.data_len = data_len,
|
|
.data_uptr = (uint64_t)data,
|
|
.out_capabilities = 0,
|
|
};
|
|
int ret;
|
|
|
|
ret = ioctl(fd, IOMMU_GET_HW_INFO, &cmd);
|
|
if (ret)
|
|
return ret;
|
|
|
|
assert(cmd.out_data_type == IOMMU_HW_INFO_TYPE_SELFTEST);
|
|
|
|
/*
|
|
* The struct iommu_test_hw_info should be the one defined
|
|
* by the current kernel.
|
|
*/
|
|
assert(cmd.data_len == sizeof(struct iommu_test_hw_info));
|
|
|
|
/*
|
|
* Trailing bytes should be 0 if user buffer is larger than
|
|
* the data that kernel reports.
|
|
*/
|
|
if (data_len > cmd.data_len) {
|
|
char *ptr = (char *)(data + cmd.data_len);
|
|
int idx = 0;
|
|
|
|
while (idx < data_len - cmd.data_len) {
|
|
assert(!*(ptr + idx));
|
|
idx++;
|
|
}
|
|
}
|
|
|
|
if (info) {
|
|
if (data_len >= offsetofend(struct iommu_test_hw_info, test_reg))
|
|
assert(info->test_reg == IOMMU_HW_INFO_SELFTEST_REGVAL);
|
|
if (data_len >= offsetofend(struct iommu_test_hw_info, flags))
|
|
assert(!info->flags);
|
|
}
|
|
|
|
if (capabilities)
|
|
*capabilities = cmd.out_capabilities;
|
|
|
|
return 0;
|
|
}
|
|
|
|
#define test_cmd_get_hw_info(device_id, data, data_len) \
|
|
ASSERT_EQ(0, _test_cmd_get_hw_info(self->fd, device_id, data, \
|
|
data_len, NULL))
|
|
|
|
#define test_err_get_hw_info(_errno, device_id, data, data_len) \
|
|
EXPECT_ERRNO(_errno, _test_cmd_get_hw_info(self->fd, device_id, data, \
|
|
data_len, NULL))
|
|
|
|
#define test_cmd_get_hw_capabilities(device_id, caps, mask) \
|
|
ASSERT_EQ(0, _test_cmd_get_hw_info(self->fd, device_id, NULL, 0, &caps))
|