Commit 97717a1f authored by Nicolin Chen's avatar Nicolin Chen Committed by Jason Gunthorpe
Browse files

iommufd/selftest: Add IOMMU_VEVENTQ_ALLOC test coverage 

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: default avatarKevin Tian <kevin.tian@intel.com>
Signed-off-by: default avatarNicolin Chen <nicolinc@nvidia.com>
Signed-off-by: default avatarJason Gunthorpe <jgg@nvidia.com>
parent b3cc0b75

tools/testing/selftests/iommu/iommufd.c

+31 −0
Original line number Diff line number Diff line
@@ -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);

	}

tools/testing/selftests/iommu/iommufd_fail_nth.c

+7 −0
Original line number Diff line number Diff line
@@ -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;

}

tools/testing/selftests/iommu/iommufd_utils.h

+115 −0
Original line number Diff line number Diff line
@@ -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))