Add a selftest, vfio_pci_sriov_uapi_test.c, to validate the
SR-IOV UAPI, including the following cases, iterating over
all the IOMMU modes currently supported:
 - Setting correct/incorrect/NULL tokens during device init.
 - Close the PF device immediately after setting the token.
 - Change/override the PF's token after device init.

Signed-off-by: Raghavendra Rao Ananta <rananta@google.com>
---
 tools/testing/selftests/vfio/Makefile         |   1 +
 .../selftests/vfio/vfio_pci_sriov_uapi_test.c | 230 ++++++++++++++++++
 2 files changed, 231 insertions(+)
 create mode 100644 tools/testing/selftests/vfio/vfio_pci_sriov_uapi_test.c

diff --git a/tools/testing/selftests/vfio/Makefile b/tools/testing/selftests/vfio/Makefile
index f27ed18070f14..d0c8cea53eb54 100644
--- a/tools/testing/selftests/vfio/Makefile
+++ b/tools/testing/selftests/vfio/Makefile
@@ -12,6 +12,7 @@ TEST_GEN_PROGS += vfio_iommufd_setup_test
 TEST_GEN_PROGS += vfio_pci_device_test
 TEST_GEN_PROGS += vfio_pci_device_init_perf_test
 TEST_GEN_PROGS += vfio_pci_driver_test
+TEST_GEN_PROGS += vfio_pci_sriov_uapi_test
 
 TEST_FILES += scripts/cleanup.sh
 TEST_FILES += scripts/lib.sh
diff --git a/tools/testing/selftests/vfio/vfio_pci_sriov_uapi_test.c b/tools/testing/selftests/vfio/vfio_pci_sriov_uapi_test.c
new file mode 100644
index 0000000000000..3acc3d78e7422
--- /dev/null
+++ b/tools/testing/selftests/vfio/vfio_pci_sriov_uapi_test.c
@@ -0,0 +1,230 @@
+// SPDX-License-Identifier: GPL-2.0-only
+#include "lib/include/libvfio/assert.h"
+#include <fcntl.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <sys/ioctl.h>
+#include <linux/limits.h>
+
+#include <libvfio.h>
+
+#include "../kselftest_harness.h"
+
+#define UUID_1 "52ac9bff-3a88-4fbd-901a-0d767c3b6c97"
+#define UUID_2 "88594674-90a0-47a9-aea8-9d9b352ac08a"
+
+static const char *pf_bdf;
+static char *vf_bdf;
+
+static pid_t main_pid;
+
+static int container_setup(struct vfio_pci_device *device, const char *bdf,
+			   const char *vf_token)
+{
+	vfio_pci_group_setup(device, bdf);
+	vfio_container_set_iommu(device);
+	__vfio_pci_group_get_device_fd(device, bdf, vf_token);
+
+	/* The device fd will be -1 in case of mismatched tokens */
+	return (device->fd < 0);
+}
+
+static int iommufd_setup(struct vfio_pci_device *device, const char *bdf,
+			 const char *vf_token)
+{
+	vfio_pci_cdev_open(device, bdf);
+	return __vfio_device_bind_iommufd(device->fd,
+					  device->iommu->iommufd, vf_token);
+}
+
+static struct vfio_pci_device *device_init(const char *bdf, struct iommu *iommu,
+					   const char *vf_token, int *out_ret)
+{
+	struct vfio_pci_device *device = vfio_pci_device_alloc(bdf, iommu);
+
+	if (iommu->mode->container_path)
+		*out_ret = container_setup(device, bdf, vf_token);
+	else
+		*out_ret = iommufd_setup(device, bdf, vf_token);
+
+	return device;
+}
+
+static void device_cleanup(struct vfio_pci_device *device)
+{
+	if (device->fd > 0)
+		VFIO_ASSERT_EQ(close(device->fd), 0);
+
+	if (device->group_fd)
+		VFIO_ASSERT_EQ(close(device->group_fd), 0);
+
+	vfio_pci_device_free(device);
+}
+
+/* clang-format off */
+FIXTURE(vfio_pci_sriov_uapi_test) {};
+/* clang-format on */
+
+FIXTURE_SETUP(vfio_pci_sriov_uapi_test)
+{
+}
+
+FIXTURE_TEARDOWN(vfio_pci_sriov_uapi_test)
+{
+}
+
+FIXTURE_VARIANT(vfio_pci_sriov_uapi_test) {
+	const char *iommu_mode;
+	char *vf_token;
+};
+
+#define FIXTURE_VARIANT_ADD_IOMMU_MODE(_iommu_mode, _name, _vf_token)		\
+FIXTURE_VARIANT_ADD(vfio_pci_sriov_uapi_test, _iommu_mode ## _ ## _name) {	\
+	.iommu_mode = #_iommu_mode,						\
+	.vf_token = (_vf_token),						\
+}
+
+FIXTURE_VARIANT_ADD_ALL_IOMMU_MODES(same_uuid, UUID_1);
+FIXTURE_VARIANT_ADD_ALL_IOMMU_MODES(diff_uuid, UUID_2);
+FIXTURE_VARIANT_ADD_ALL_IOMMU_MODES(null_uuid, NULL);
+
+/*
+ * PF's token is always set with UUID_1 and VF's token is rotated with
+ * various tokens (including UUID_1 and NULL).
+ * This asserts if the VF device is successfully created for a match
+ * in the token or actually fails during a mismatch.
+ */
+#define ASSERT_VF_CREATION(_ret) do {					\
+	if (!variant->vf_token || strcmp(UUID_1, variant->vf_token)) {	\
+		ASSERT_NE((_ret), 0);					\
+	} else {							\
+		ASSERT_EQ((_ret), 0);					\
+	}								\
+} while (0)
+
+/*
+ * Validate if the UAPI handles correctly and incorrectly set token on the VF.
+ */
+TEST_F(vfio_pci_sriov_uapi_test, init_token_match)
+{
+	struct vfio_pci_device *pf;
+	struct vfio_pci_device *vf;
+	struct iommu *iommu;
+	int ret;
+
+	iommu = iommu_init(variant->iommu_mode);
+
+	pf = device_init(pf_bdf, iommu, UUID_1, &ret);
+	ASSERT_EQ(ret, 0);
+
+	vf = device_init(vf_bdf, iommu, variant->vf_token, &ret);
+	ASSERT_VF_CREATION(ret);
+
+	device_cleanup(vf);
+	device_cleanup(pf);
+	iommu_cleanup(iommu);
+}
+
+/*
+ * After setting a token on the PF, validate if the VF can still set the
+ * expected token.
+ */
+TEST_F(vfio_pci_sriov_uapi_test, pf_early_close)
+{
+	struct vfio_pci_device *pf;
+	struct vfio_pci_device *vf;
+	struct iommu *iommu;
+	int ret;
+
+	iommu = iommu_init(variant->iommu_mode);
+
+	pf = device_init(pf_bdf, iommu, UUID_1, &ret);
+	ASSERT_EQ(ret, 0);
+	device_cleanup(pf);
+
+	vf = device_init(vf_bdf, iommu, variant->vf_token, &ret);
+	ASSERT_VF_CREATION(ret);
+
+	device_cleanup(vf);
+	iommu_cleanup(iommu);
+}
+
+/*
+ * After PF device init, override the existing token and validate if the newly
+ * set token is the one that's active.
+ */
+TEST_F(vfio_pci_sriov_uapi_test, override_token)
+{
+	struct vfio_pci_device *pf;
+	struct vfio_pci_device *vf;
+	struct iommu *iommu;
+	int ret;
+
+	iommu = iommu_init(variant->iommu_mode);
+
+	pf = device_init(pf_bdf, iommu, UUID_2, &ret);
+	ASSERT_EQ(ret, 0);
+	vfio_device_set_vf_token(pf->fd, UUID_1);
+
+	vf = device_init(vf_bdf, iommu, variant->vf_token, &ret);
+	ASSERT_VF_CREATION(ret);
+
+	device_cleanup(vf);
+	device_cleanup(pf);
+	iommu_cleanup(iommu);
+}
+
+static void vf_teardown(void)
+{
+	/* Destroy the VF only when the main/parent process exits. */
+	if (getpid() != main_pid)
+		return;
+
+	free(vf_bdf);
+	sysfs_sriov_numvfs_set(pf_bdf, 0);
+}
+
+static void vf_setup(void)
+{
+	char *vf_driver;
+	int nr_vfs;
+
+	nr_vfs = sysfs_sriov_totalvfs_get(pf_bdf);
+	if (nr_vfs <= 0)
+		ksft_exit_skip("SR-IOV may not be supported by the PF: %s\n", pf_bdf);
+
+	nr_vfs = sysfs_sriov_numvfs_get(pf_bdf);
+	if (nr_vfs != 0)
+		ksft_exit_skip("SR-IOV already configured for the PF: %s\n", pf_bdf);
+
+	/* Create only one VF for testing */
+	sysfs_sriov_numvfs_set(pf_bdf, 1);
+
+	/*
+	 * Setup an exit handler to destroy the VF in case of failures
+	 * during further setup at the end of the test run.
+	 */
+	main_pid = getpid();
+	VFIO_ASSERT_EQ(atexit(vf_teardown), 0);
+
+	vf_bdf = sysfs_sriov_vf_bdf_get(pf_bdf, 0);
+
+	/*
+	 * The VF inherits the driver from the PF.
+	 * Ensure this is 'vfio-pci' before proceeding.
+	 */
+	vf_driver = sysfs_driver_get(vf_bdf);
+	VFIO_ASSERT_NE(vf_driver, NULL);
+	VFIO_ASSERT_EQ(strcmp(vf_driver, "vfio-pci"), 0);
+	free(vf_driver);
+
+	printf("Created 1 VF (%s) under the PF: %s\n", vf_bdf, pf_bdf);
+}
+
+int main(int argc, char *argv[])
+{
+	pf_bdf = vfio_selftests_get_bdf(&argc, argv);
+	vf_setup();
+
+	return test_harness_run(argc, argv);
+}
-- 
2.53.0.1213.gd9a14994de-goog

On 2026-04-02 05:30 PM, Raghavendra Rao Ananta wrote:

> +/* clang-format off */
> +FIXTURE(vfio_pci_sriov_uapi_test) {};
> +/* clang-format on */
> +
> +FIXTURE_SETUP(vfio_pci_sriov_uapi_test)
> +{
> +}
> +
> +FIXTURE_TEARDOWN(vfio_pci_sriov_uapi_test)
> +{
> +}

Please do iommu_init() iommu_cleanup() here to reduce code duplication
and as an added bonus you can drop the clang-format comments above.

> +static void vf_teardown(void)
> +{
> +	/* Destroy the VF only when the main/parent process exits. */
> +	if (getpid() != main_pid)
> +		return;

Is this because the child processes created by test_harness_run() to run
the TEST_F()s inherit the atexit() call? If so please clarify that in
the comment in more detail.

> +
> +	free(vf_bdf);
> +	sysfs_sriov_numvfs_set(pf_bdf, 0);
> +}
> +
> +static void vf_setup(void)
> +{
> +	char *vf_driver;
> +	int nr_vfs;
> +
> +	nr_vfs = sysfs_sriov_totalvfs_get(pf_bdf);
> +	if (nr_vfs <= 0)
> +		ksft_exit_skip("SR-IOV may not be supported by the PF: %s\n", pf_bdf);
> +
> +	nr_vfs = sysfs_sriov_numvfs_get(pf_bdf);
> +	if (nr_vfs != 0)
> +		ksft_exit_skip("SR-IOV already configured for the PF: %s\n", pf_bdf);
> +
> +	/* Create only one VF for testing */
> +	sysfs_sriov_numvfs_set(pf_bdf, 1);
> +
> +	/*
> +	 * Setup an exit handler to destroy the VF in case of failures
> +	 * during further setup at the end of the test run.
> +	 */
> +	main_pid = getpid();
> +	VFIO_ASSERT_EQ(atexit(vf_teardown), 0);
> +
> +	vf_bdf = sysfs_sriov_vf_bdf_get(pf_bdf, 0);
> +
> +	/*
> +	 * The VF inherits the driver from the PF.
> +	 * Ensure this is 'vfio-pci' before proceeding.
> +	 */
> +	vf_driver = sysfs_driver_get(vf_bdf);
> +	VFIO_ASSERT_NE(vf_driver, NULL);
> +	VFIO_ASSERT_EQ(strcmp(vf_driver, "vfio-pci"), 0);
> +	free(vf_driver);
> +
> +	printf("Created 1 VF (%s) under the PF: %s\n", vf_bdf, pf_bdf);

Do we actually need atexit()? This code can go into main and we can do
the VF cleanup before returning from main after test_harness_run()
returns. I don't think you even need to check the VF driver. If the VF
is not bound to vfio-pci then that will be caught by the test cases when
they call device_init(vf_bdf, ...).

That would make the logic more straightforward and get rid of the
main_pid stuff too.

On Mon, Apr 6, 2026 at 3:24 PM David Matlack <dmatlack@google.com> wrote:
>
> On 2026-04-02 05:30 PM, Raghavendra Rao Ananta wrote:
>
> > +/* clang-format off */
> > +FIXTURE(vfio_pci_sriov_uapi_test) {};
> > +/* clang-format on */
> > +
> > +FIXTURE_SETUP(vfio_pci_sriov_uapi_test)
> > +{
> > +}
> > +
> > +FIXTURE_TEARDOWN(vfio_pci_sriov_uapi_test)
> > +{
> > +}
>
> Please do iommu_init() iommu_cleanup() here to reduce code duplication
> and as an added bonus you can drop the clang-format comments above.
>
I think even Vipin suggested this. Last time I tried this, IIRC got a
build error that 'variant' was inaccessible. But I guess I just had to
re-org my code to make it work.
I'll do this in v8.

> > +static void vf_teardown(void)
> > +{
> > +     /* Destroy the VF only when the main/parent process exits. */
> > +     if (getpid() != main_pid)
> > +             return;
>
> Is this because the child processes created by test_harness_run() to run
> the TEST_F()s inherit the atexit() call? If so please clarify that in
> the comment in more detail.
>
Yes, that's the reason, and I assumed the comment made that clear.
I'll re-write it if required.

> > +
> > +     free(vf_bdf);
> > +     sysfs_sriov_numvfs_set(pf_bdf, 0);
> > +}
> > +
> > +static void vf_setup(void)
> > +{
> > +     char *vf_driver;
> > +     int nr_vfs;
> > +
> > +     nr_vfs = sysfs_sriov_totalvfs_get(pf_bdf);
> > +     if (nr_vfs <= 0)
> > +             ksft_exit_skip("SR-IOV may not be supported by the PF: %s\n", pf_bdf);
> > +
> > +     nr_vfs = sysfs_sriov_numvfs_get(pf_bdf);
> > +     if (nr_vfs != 0)
> > +             ksft_exit_skip("SR-IOV already configured for the PF: %s\n", pf_bdf);
> > +
> > +     /* Create only one VF for testing */
> > +     sysfs_sriov_numvfs_set(pf_bdf, 1);
> > +
> > +     /*
> > +      * Setup an exit handler to destroy the VF in case of failures
> > +      * during further setup at the end of the test run.
> > +      */
> > +     main_pid = getpid();
> > +     VFIO_ASSERT_EQ(atexit(vf_teardown), 0);
> > +
> > +     vf_bdf = sysfs_sriov_vf_bdf_get(pf_bdf, 0);
> > +
> > +     /*
> > +      * The VF inherits the driver from the PF.
> > +      * Ensure this is 'vfio-pci' before proceeding.
> > +      */
> > +     vf_driver = sysfs_driver_get(vf_bdf);
> > +     VFIO_ASSERT_NE(vf_driver, NULL);
> > +     VFIO_ASSERT_EQ(strcmp(vf_driver, "vfio-pci"), 0);
> > +     free(vf_driver);
> > +
> > +     printf("Created 1 VF (%s) under the PF: %s\n", vf_bdf, pf_bdf);
>
> Do we actually need atexit()? This code can go into main and we can do
> the VF cleanup before returning from main after test_harness_run()
> returns. I don't think you even need to check the VF driver. If the VF
> is not bound to vfio-pci then that will be caught by the test cases when
> they call device_init(vf_bdf, ...).
>
Other than the asserts on 'vf_driver', the calls to
`sysfs_sriov_vf_bdf_get()` and `sysfs_driver_get()` themselves have a
potential chance of triggering asserts, although this is unlikely.
But the bigger reason is that test_harness_run() unconditionally calls
ksft_exit() at the end, forcing it to be the last function called from
main(), regardless of the tests' outcome. Hence, the exit handler.

I see atexit() used in some selftests, so I thought it was normal and
acceptable.

Thank you.
Raghavendra

On Tue, Apr 7, 2026 at 1:51 PM Raghavendra Rao Ananta
<rananta@google.com> wrote:
>
> On Mon, Apr 6, 2026 at 3:24 PM David Matlack <dmatlack@google.com> wrote:
> >
> > On 2026-04-02 05:30 PM, Raghavendra Rao Ananta wrote:
> >
> > > +/* clang-format off */
> > > +FIXTURE(vfio_pci_sriov_uapi_test) {};
> > > +/* clang-format on */
> > > +
> > > +FIXTURE_SETUP(vfio_pci_sriov_uapi_test)
> > > +{
> > > +}
> > > +
> > > +FIXTURE_TEARDOWN(vfio_pci_sriov_uapi_test)
> > > +{
> > > +}
> >
> > Please do iommu_init() iommu_cleanup() here to reduce code duplication
> > and as an added bonus you can drop the clang-format comments above.
> >
> I think even Vipin suggested this. Last time I tried this, IIRC got a
> build error that 'variant' was inaccessible. But I guess I just had to
> re-org my code to make it work.
> I'll do this in v8.
>
> > > +static void vf_teardown(void)
> > > +{
> > > +     /* Destroy the VF only when the main/parent process exits. */
> > > +     if (getpid() != main_pid)
> > > +             return;
> >
> > Is this because the child processes created by test_harness_run() to run
> > the TEST_F()s inherit the atexit() call? If so please clarify that in
> > the comment in more detail.
> >
> Yes, that's the reason, and I assumed the comment made that clear.
> I'll re-write it if required.
>
> > > +
> > > +     free(vf_bdf);
> > > +     sysfs_sriov_numvfs_set(pf_bdf, 0);
> > > +}
> > > +
> > > +static void vf_setup(void)
> > > +{
> > > +     char *vf_driver;
> > > +     int nr_vfs;
> > > +
> > > +     nr_vfs = sysfs_sriov_totalvfs_get(pf_bdf);
> > > +     if (nr_vfs <= 0)
> > > +             ksft_exit_skip("SR-IOV may not be supported by the PF: %s\n", pf_bdf);
> > > +
> > > +     nr_vfs = sysfs_sriov_numvfs_get(pf_bdf);
> > > +     if (nr_vfs != 0)
> > > +             ksft_exit_skip("SR-IOV already configured for the PF: %s\n", pf_bdf);
> > > +
> > > +     /* Create only one VF for testing */
> > > +     sysfs_sriov_numvfs_set(pf_bdf, 1);
> > > +
> > > +     /*
> > > +      * Setup an exit handler to destroy the VF in case of failures
> > > +      * during further setup at the end of the test run.
> > > +      */
> > > +     main_pid = getpid();
> > > +     VFIO_ASSERT_EQ(atexit(vf_teardown), 0);
> > > +
> > > +     vf_bdf = sysfs_sriov_vf_bdf_get(pf_bdf, 0);
> > > +
> > > +     /*
> > > +      * The VF inherits the driver from the PF.
> > > +      * Ensure this is 'vfio-pci' before proceeding.
> > > +      */
> > > +     vf_driver = sysfs_driver_get(vf_bdf);
> > > +     VFIO_ASSERT_NE(vf_driver, NULL);
> > > +     VFIO_ASSERT_EQ(strcmp(vf_driver, "vfio-pci"), 0);
> > > +     free(vf_driver);
> > > +
> > > +     printf("Created 1 VF (%s) under the PF: %s\n", vf_bdf, pf_bdf);
> >
> > Do we actually need atexit()? This code can go into main and we can do
> > the VF cleanup before returning from main after test_harness_run()
> > returns. I don't think you even need to check the VF driver. If the VF
> > is not bound to vfio-pci then that will be caught by the test cases when
> > they call device_init(vf_bdf, ...).
> >
> Other than the asserts on 'vf_driver', the calls to
> `sysfs_sriov_vf_bdf_get()` and `sysfs_driver_get()` themselves have a
> potential chance of triggering asserts, although this is unlikely.
> But the bigger reason is that test_harness_run() unconditionally calls
> ksft_exit() at the end, forcing it to be the last function called from
> main(), regardless of the tests' outcome. Hence, the exit handler.
>
> I see atexit() used in some selftests, so I thought it was normal and
> acceptable.

Ah ok if test_harness_run() exits instead of returning then I agree
with using atexit(). Thanks for the explanation!