mirrors/linux
1
0
Fork 0
mirror of https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git synced 2025-12-27 17:01:25 -05:00
Code Issues Packages Projects Releases Wiki Activity

iommufd/selftest: Add IOMMU_VEVENTQ_ALLOC test coverage

Browse Source 
Trigger vEVENTs by feeding an idev ID and validating the returned output
virt_ids whether they equal to the value that was set to the vDEVICE.

Link: https://patch.msgid.link/r/e829532ec0a3927d61161b7674b20e731ecd495b.1741719725.git.nicolinc@nvidia.com
Reviewed-by: Kevin Tian <kevin.tian@intel.com>
Signed-off-by: Nicolin Chen <nicolinc@nvidia.com>
Signed-off-by: Jason Gunthorpe <jgg@nvidia.com>
This commit is contained in:
Nicolin Chen
2025-03-11 12:44:28 -07:00
committed by Jason Gunthorpe
parent b3cc0b7599
commit 97717a1f28
3 changed files with 153 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

31
tools/testing/selftests/iommu/iommufd.c
View File

@@ -2778,15 +2778,46 @@ TEST_F(iommufd_viommu, vdevice_alloc)
uint32_t viommu_id = self->viommu_id;
uint32_t dev_id = self->device_id;
uint32_t vdev_id = 0;
uint32_t veventq_id;
uint32_t veventq_fd;
int prev_seq = -1;
if (dev_id) {
/* Must allocate vdevice before attaching to a nested hwpt */
test_err_mock_domain_replace(ENOENT, self->stdev_id,
self->nested_hwpt_id);
/* Allocate a vEVENTQ with veventq_depth=2 */
test_cmd_veventq_alloc(viommu_id, IOMMU_VEVENTQ_TYPE_SELFTEST,
&veventq_id, &veventq_fd);
test_err_veventq_alloc(EEXIST, viommu_id,
IOMMU_VEVENTQ_TYPE_SELFTEST, NULL, NULL);
/* Set vdev_id to 0x99, unset it, and set to 0x88 */
test_cmd_vdevice_alloc(viommu_id, dev_id, 0x99, &vdev_id);
test_cmd_mock_domain_replace(self->stdev_id,
self->nested_hwpt_id);
test_cmd_trigger_vevents(dev_id, 1);
test_cmd_read_vevents(veventq_fd, 1, 0x99, &prev_seq);
test_err_vdevice_alloc(EEXIST, viommu_id, dev_id, 0x99,
&vdev_id);
test_cmd_mock_domain_replace(self->stdev_id, self->ioas_id);
test_ioctl_destroy(vdev_id);
/* Try again with 0x88 */
test_cmd_vdevice_alloc(viommu_id, dev_id, 0x88, &vdev_id);
test_cmd_mock_domain_replace(self->stdev_id,
self->nested_hwpt_id);
/* Trigger an overflow with three events */
test_cmd_trigger_vevents(dev_id, 3);
test_err_read_vevents(EOVERFLOW, veventq_fd, 3, 0x88,
&prev_seq);
/* Overflow must be gone after the previous reads */
test_cmd_trigger_vevents(dev_id, 1);
test_cmd_read_vevents(veventq_fd, 1, 0x88, &prev_seq);
close(veventq_fd);
test_cmd_mock_domain_replace(self->stdev_id, self->ioas_id);
test_ioctl_destroy(vdev_id);
test_ioctl_destroy(veventq_id);
} else {
test_err_vdevice_alloc(ENOENT, viommu_id, dev_id, 0x99, NULL);
}

7
tools/testing/selftests/iommu/iommufd_fail_nth.c
View File

@@ -620,6 +620,7 @@ TEST_FAIL_NTH(basic_fail_nth, device)
};
struct iommu_test_hw_info info;
uint32_t fault_id, fault_fd;
uint32_t veventq_id, veventq_fd;
uint32_t fault_hwpt_id;
uint32_t ioas_id;
uint32_t ioas_id2;
@@ -692,6 +693,12 @@ TEST_FAIL_NTH(basic_fail_nth, device)
IOMMU_HWPT_DATA_SELFTEST, &data, sizeof(data)))
return -1;
if (_test_cmd_veventq_alloc(self->fd, viommu_id,
IOMMU_VEVENTQ_TYPE_SELFTEST, &veventq_id,
&veventq_fd))
return -1;
close(veventq_fd);
return 0;
}

115
tools/testing/selftests/iommu/iommufd_utils.h
View File

@@ -9,6 +9,7 @@
#include <sys/ioctl.h>
#include <stdint.h>
#include <assert.h>
#include <poll.h>
#include "../kselftest_harness.h"
#include "../../../../drivers/iommu/iommufd/iommufd_test.h"
@@ -936,3 +937,117 @@ static int _test_cmd_vdevice_alloc(int fd, __u32 viommu_id, __u32 idev_id,
EXPECT_ERRNO(_errno, \
_test_cmd_vdevice_alloc(self->fd, viommu_id, idev_id, \
virt_id, vdev_id))
static int _test_cmd_veventq_alloc(int fd, __u32 viommu_id, __u32 type,
__u32 *veventq_id, __u32 *veventq_fd)
{
struct iommu_veventq_alloc cmd = {
.size = sizeof(cmd),
.type = type,
.veventq_depth = 2,
.viommu_id = viommu_id,
};
int ret;
ret = ioctl(fd, IOMMU_VEVENTQ_ALLOC, &cmd);
if (ret)
return ret;
if (veventq_id)
*veventq_id = cmd.out_veventq_id;
if (veventq_fd)
*veventq_fd = cmd.out_veventq_fd;
return 0;
}
#define test_cmd_veventq_alloc(viommu_id, type, veventq_id, veventq_fd) \
ASSERT_EQ(0, _test_cmd_veventq_alloc(self->fd, viommu_id, type, \
veventq_id, veventq_fd))
#define test_err_veventq_alloc(_errno, viommu_id, type, veventq_id, \
veventq_fd) \
EXPECT_ERRNO(_errno, \
_test_cmd_veventq_alloc(self->fd, viommu_id, type, \
veventq_id, veventq_fd))
static int _test_cmd_trigger_vevents(int fd, __u32 dev_id, __u32 nvevents)
{
struct iommu_test_cmd trigger_vevent_cmd = {
.size = sizeof(trigger_vevent_cmd),
.op = IOMMU_TEST_OP_TRIGGER_VEVENT,
.trigger_vevent = {
.dev_id = dev_id,
},
};
int ret;
while (nvevents--) {
ret = ioctl(fd, _IOMMU_TEST_CMD(IOMMU_TEST_OP_TRIGGER_VEVENT),
&trigger_vevent_cmd);
if (ret < 0)
return -1;
}
return ret;
}
#define test_cmd_trigger_vevents(dev_id, nvevents) \
ASSERT_EQ(0, _test_cmd_trigger_vevents(self->fd, dev_id, nvevents))
static int _test_cmd_read_vevents(int fd, __u32 event_fd, __u32 nvevents,
__u32 virt_id, int *prev_seq)
{
struct pollfd pollfd = { .fd = event_fd, .events = POLLIN };
struct iommu_viommu_event_selftest *event;
struct iommufd_vevent_header *hdr;
ssize_t bytes;
void *data;
int ret, i;
ret = poll(&pollfd, 1, 1000);
if (ret < 0)
return -1;
data = calloc(nvevents, sizeof(*hdr) + sizeof(*event));
if (!data) {
errno = ENOMEM;
return -1;
}
bytes = read(event_fd, data,
nvevents * (sizeof(*hdr) + sizeof(*event)));
if (bytes <= 0) {
errno = EFAULT;
ret = -1;
goto out_free;
}
for (i = 0; i < nvevents; i++) {
hdr = data + i * (sizeof(*hdr) + sizeof(*event));
if (hdr->flags & IOMMU_VEVENTQ_FLAG_LOST_EVENTS ||
hdr->sequence - *prev_seq > 1) {
*prev_seq = hdr->sequence;
errno = EOVERFLOW;
ret = -1;
goto out_free;
}
*prev_seq = hdr->sequence;
event = data + sizeof(*hdr);
if (event->virt_id != virt_id) {
errno = EINVAL;
ret = -1;
goto out_free;
}
}
ret = 0;
out_free:
free(data);
return ret;
}
#define test_cmd_read_vevents(event_fd, nvevents, virt_id, prev_seq) \
ASSERT_EQ(0, _test_cmd_read_vevents(self->fd, event_fd, nvevents, \
virt_id, prev_seq))
#define test_err_read_vevents(_errno, event_fd, nvevents, virt_id, prev_seq) \
EXPECT_ERRNO(_errno, \
_test_cmd_read_vevents(self->fd, event_fd, nvevents, \
virt_id, prev_seq))