Commit 6df969b7 authored by Linus Torvalds's avatar Linus Torvalds
Browse files

Merge tag 'for-linus-iommufd' of git://git.kernel.org/pub/scm/linux/kernel/git/jgg/iommufd 

Pull iommufd updates from Jason Gunthorpe:
 "Two series:

   - Reorganize how the hardware page table objects are managed,
     particularly their destruction flow. Increase the selftest test
     coverage in this area by creating a more complete mock iommu
     driver.

     This is preparation to add a replace operation for HWPT binding,
     which is done but waiting for the VFIO parts to complete so there
     is a user.

   - Split the iommufd support for "access" to make it two step -
     allocate an access then link it to an IOAS. Update VFIO and have
     VFIO always create an access even for the VFIO mdevs that never do
     DMA.

     This is also preperation for the replace VFIO series that will
     allow replace to work on access types as well.

  Three minor fixes:

   - Sykzaller found the selftest code didn't check for overflow when
     processing user VAs

   - smatch noted a .data item should have been static

   - Add a selftest that reproduces a syzkaller bug for batch carry
     already fixed in rc"

* tag 'for-linus-iommufd' of git://git.kernel.org/pub/scm/linux/kernel/git/jgg/iommufd: (21 commits)
  iommufd/selftest: Cover domain unmap with huge pages and access
  iommufd/selftest: Set varaiable mock_iommu_device storage-class-specifier to static
  vfio: Check the presence for iommufd callbacks in __vfio_register_dev()
  vfio/mdev: Uses the vfio emulated iommufd ops set in the mdev sample drivers
  vfio-iommufd: Make vfio_iommufd_emulated_bind() return iommufd_access ID
  vfio-iommufd: No need to record iommufd_ctx in vfio_device
  iommufd: Create access in vfio_iommufd_emulated_bind()
  iommu/iommufd: Pass iommufd_ctx pointer in iommufd_get_ioas()
  iommufd/selftest: Catch overflow of uptr and length
  iommufd/selftest: Add a selftest for iommufd_device_attach() with a hwpt argument
  iommufd/selftest: Make selftest create a more complete mock device
  iommufd/selftest: Rename the remaining mock device_id's to stdev_id
  iommufd/selftest: Rename domain_id to hwpt_id for FIXTURE iommufd_mock_domain
  iommufd/selftest: Rename domain_id to stdev_id for FIXTURE iommufd_ioas
  iommufd/selftest: Rename the sefltest 'device_id' to 'stdev_id'
  iommufd: Make iommufd_hw_pagetable_alloc() do iopt_table_add_domain()
  iommufd: Move iommufd_device to iommufd_private.h
  iommufd: Move ioas related HWPT destruction into iommufd_hw_pagetable_destroy()
  iommufd: Consistently manage hwpt_item
  iommufd: Add iommufd_lock_obj() around the auto-domains hwpts
  ...
parents 32f7ad0f 62e37c86

drivers/iommu/iommufd/device.c

+80 −125
Original line number Diff line number Diff line
@@ -15,23 +15,6 @@ MODULE_PARM_DESC( 
	"Allow IOMMUFD to bind to devices even if the platform cannot isolate "

	"the MSI interrupt window. Enabling this is a security weakness.");



/*

 * A iommufd_device object represents the binding relationship between a

 * consuming driver and the iommufd. These objects are created/destroyed by

 * external drivers, not by userspace.

 */

struct iommufd_device {

	struct iommufd_object obj;

	struct iommufd_ctx *ictx;

	struct iommufd_hw_pagetable *hwpt;

	/* Head at iommufd_hw_pagetable::devices */

	struct list_head devices_item;

	/* always the physical device */

	struct device *dev;

	struct iommu_group *group;

	bool enforce_cache_coherency;

};



void iommufd_device_destroy(struct iommufd_object *obj)

{

	struct iommufd_device *idev =
@@ -39,6 +22,7 @@ void iommufd_device_destroy(struct iommufd_object *obj) 


	iommu_device_release_dma_owner(idev->dev);

	iommu_group_put(idev->group);

	if (!iommufd_selftest_is_mock_dev(idev->dev))

		iommufd_ctx_put(idev->ictx);

}
@@ -86,6 +70,7 @@ struct iommufd_device *iommufd_device_bind(struct iommufd_ctx *ictx, 
		goto out_release_owner;

	}

	idev->ictx = ictx;

	if (!iommufd_selftest_is_mock_dev(dev))

		iommufd_ctx_get(ictx);

	idev->dev = dev;

	idev->enforce_cache_coherency =
@@ -168,7 +153,8 @@ static int iommufd_device_setup_msi(struct iommufd_device *idev, 
	 * operation from the device (eg a simple DMA) cannot trigger an

	 * interrupt outside this iommufd context.

	 */

	if (!iommu_group_has_isolated_msi(idev->group)) {

	if (!iommufd_selftest_is_mock_dev(idev->dev) &&

	    !iommu_group_has_isolated_msi(idev->group)) {

		if (!allow_unsafe_interrupts)

			return -EPERM;
@@ -186,19 +172,24 @@ static bool iommufd_hw_pagetable_has_group(struct iommufd_hw_pagetable *hwpt, 
{

	struct iommufd_device *cur_dev;



	lockdep_assert_held(&hwpt->devices_lock);



	list_for_each_entry(cur_dev, &hwpt->devices, devices_item)

		if (cur_dev->group == group)

			return true;

	return false;

}



static int iommufd_device_do_attach(struct iommufd_device *idev,

				    struct iommufd_hw_pagetable *hwpt)

int iommufd_hw_pagetable_attach(struct iommufd_hw_pagetable *hwpt,

				struct iommufd_device *idev)

{

	phys_addr_t sw_msi_start = PHYS_ADDR_MAX;

	int rc;



	mutex_lock(&hwpt->devices_lock);

	lockdep_assert_held(&hwpt->devices_lock);



	if (WARN_ON(idev->hwpt))

		return -EINVAL;



	/*

	 * Try to upgrade the domain we have, it is an iommu driver bug to
@@ -213,19 +204,18 @@ static int iommufd_device_do_attach(struct iommufd_device *idev, 
					hwpt->domain);

		if (!hwpt->enforce_cache_coherency) {

			WARN_ON(list_empty(&hwpt->devices));

			rc = -EINVAL;

			goto out_unlock;

			return -EINVAL;

		}

	}



	rc = iopt_table_enforce_group_resv_regions(&hwpt->ioas->iopt, idev->dev,

						   idev->group, &sw_msi_start);

	if (rc)

		goto out_unlock;

		return rc;



	rc = iommufd_device_setup_msi(idev, hwpt, sw_msi_start);

	if (rc)

		goto out_iova;

		goto err_unresv;



	/*

	 * FIXME: Hack around missing a device-centric iommu api, only attach to
@@ -234,26 +224,35 @@ static int iommufd_device_do_attach(struct iommufd_device *idev, 
	if (!iommufd_hw_pagetable_has_group(hwpt, idev->group)) {

		rc = iommu_attach_group(hwpt->domain, idev->group);

		if (rc)

			goto out_iova;



		if (list_empty(&hwpt->devices)) {

			rc = iopt_table_add_domain(&hwpt->ioas->iopt,

						   hwpt->domain);

			if (rc)

				goto out_detach;

			goto err_unresv;

	}

	return 0;

err_unresv:

	iopt_remove_reserved_iova(&hwpt->ioas->iopt, idev->dev);

	return rc;

}



void iommufd_hw_pagetable_detach(struct iommufd_hw_pagetable *hwpt,

				 struct iommufd_device *idev)

{

	if (!iommufd_hw_pagetable_has_group(hwpt, idev->group))

		iommu_detach_group(hwpt->domain, idev->group);

	iopt_remove_reserved_iova(&hwpt->ioas->iopt, idev->dev);

}



static int iommufd_device_do_attach(struct iommufd_device *idev,

				    struct iommufd_hw_pagetable *hwpt)

{

	int rc;



	mutex_lock(&hwpt->devices_lock);

	rc = iommufd_hw_pagetable_attach(hwpt, idev);

	if (rc)

		goto out_unlock;



	idev->hwpt = hwpt;

	refcount_inc(&hwpt->obj.users);

	list_add(&idev->devices_item, &hwpt->devices);

	mutex_unlock(&hwpt->devices_lock);

	return 0;



out_detach:

	iommu_detach_group(hwpt->domain, idev->group);

out_iova:

	iopt_remove_reserved_iova(&hwpt->ioas->iopt, idev->dev);

out_unlock:

	mutex_unlock(&hwpt->devices_lock);

	return rc;
@@ -280,7 +279,10 @@ static int iommufd_device_auto_get_domain(struct iommufd_device *idev, 
		if (!hwpt->auto_domain)

			continue;



		if (!iommufd_lock_obj(&hwpt->obj))

			continue;

		rc = iommufd_device_do_attach(idev, hwpt);

		iommufd_put_object(&hwpt->obj);



		/*

		 * -EINVAL means the domain is incompatible with the device.
@@ -292,24 +294,16 @@ static int iommufd_device_auto_get_domain(struct iommufd_device *idev, 
		goto out_unlock;

	}



	hwpt = iommufd_hw_pagetable_alloc(idev->ictx, ioas, idev->dev);

	hwpt = iommufd_hw_pagetable_alloc(idev->ictx, ioas, idev, true);

	if (IS_ERR(hwpt)) {

		rc = PTR_ERR(hwpt);

		goto out_unlock;

	}

	hwpt->auto_domain = true;



	rc = iommufd_device_do_attach(idev, hwpt);

	if (rc)

		goto out_abort;

	list_add_tail(&hwpt->hwpt_item, &ioas->hwpt_list);



	mutex_unlock(&ioas->mutex);

	iommufd_object_finalize(idev->ictx, &hwpt->obj);

	return 0;



out_abort:

	iommufd_object_abort_and_destroy(idev->ictx, &hwpt->obj);

out_unlock:

	mutex_unlock(&ioas->mutex);

	return rc;
@@ -381,28 +375,17 @@ void iommufd_device_detach(struct iommufd_device *idev) 
{

	struct iommufd_hw_pagetable *hwpt = idev->hwpt;



	mutex_lock(&hwpt->ioas->mutex);

	mutex_lock(&hwpt->devices_lock);

	list_del(&idev->devices_item);

	if (!iommufd_hw_pagetable_has_group(hwpt, idev->group)) {

		if (list_empty(&hwpt->devices)) {

			iopt_table_remove_domain(&hwpt->ioas->iopt,

						 hwpt->domain);

			list_del(&hwpt->hwpt_item);

		}

		iommu_detach_group(hwpt->domain, idev->group);

	}

	iopt_remove_reserved_iova(&hwpt->ioas->iopt, idev->dev);

	idev->hwpt = NULL;

	iommufd_hw_pagetable_detach(hwpt, idev);

	mutex_unlock(&hwpt->devices_lock);

	mutex_unlock(&hwpt->ioas->mutex);



	if (hwpt->auto_domain)

		iommufd_object_destroy_user(idev->ictx, &hwpt->obj);

	else

		refcount_dec(&hwpt->obj.users);



	idev->hwpt = NULL;



	refcount_dec(&idev->obj.users);

}

EXPORT_SYMBOL_NS_GPL(iommufd_device_detach, IOMMUFD);
@@ -412,17 +395,20 @@ void iommufd_access_destroy_object(struct iommufd_object *obj) 
	struct iommufd_access *access =

		container_of(obj, struct iommufd_access, obj);



	if (access->ioas) {

		iopt_remove_access(&access->ioas->iopt, access);

	iommufd_ctx_put(access->ictx);

		refcount_dec(&access->ioas->obj.users);

		access->ioas = NULL;

	}

	iommufd_ctx_put(access->ictx);

}



/**

 * iommufd_access_create - Create an iommufd_access

 * @ictx: iommufd file descriptor

 * @ioas_id: ID for a IOMMUFD_OBJ_IOAS

 * @ops: Driver's ops to associate with the access

 * @data: Opaque data to pass into ops functions

 * @id: Output ID number to return to userspace for this access

 *

 * An iommufd_access allows a driver to read/write to the IOAS without using

 * DMA. The underlying CPU memory can be accessed using the
@@ -431,12 +417,10 @@ void iommufd_access_destroy_object(struct iommufd_object *obj) 
 * The provided ops are required to use iommufd_access_pin_pages().

 */

struct iommufd_access *

iommufd_access_create(struct iommufd_ctx *ictx, u32 ioas_id,

		      const struct iommufd_access_ops *ops, void *data)

iommufd_access_create(struct iommufd_ctx *ictx,

		      const struct iommufd_access_ops *ops, void *data, u32 *id)

{

	struct iommufd_access *access;

	struct iommufd_object *obj;

	int rc;



	/*

	 * There is no uAPI for the access object, but to keep things symmetric
@@ -449,33 +433,18 @@ iommufd_access_create(struct iommufd_ctx *ictx, u32 ioas_id, 
	access->data = data;

	access->ops = ops;



	obj = iommufd_get_object(ictx, ioas_id, IOMMUFD_OBJ_IOAS);

	if (IS_ERR(obj)) {

		rc = PTR_ERR(obj);

		goto out_abort;

	}

	access->ioas = container_of(obj, struct iommufd_ioas, obj);

	iommufd_ref_to_users(obj);



	if (ops->needs_pin_pages)

		access->iova_alignment = PAGE_SIZE;

	else

		access->iova_alignment = 1;

	rc = iopt_add_access(&access->ioas->iopt, access);

	if (rc)

		goto out_put_ioas;



	/* The calling driver is a user until iommufd_access_destroy() */

	refcount_inc(&access->obj.users);

	access->ictx = ictx;

	iommufd_ctx_get(ictx);

	iommufd_object_finalize(ictx, &access->obj);

	*id = access->obj.id;

	return access;

out_put_ioas:

	refcount_dec(&access->ioas->obj.users);

out_abort:

	iommufd_object_abort(ictx, &access->obj);

	return ERR_PTR(rc);

}

EXPORT_SYMBOL_NS_GPL(iommufd_access_create, IOMMUFD);
@@ -494,6 +463,30 @@ void iommufd_access_destroy(struct iommufd_access *access) 
}

EXPORT_SYMBOL_NS_GPL(iommufd_access_destroy, IOMMUFD);



int iommufd_access_attach(struct iommufd_access *access, u32 ioas_id)

{

	struct iommufd_ioas *new_ioas;

	int rc = 0;



	if (access->ioas)

		return -EINVAL;



	new_ioas = iommufd_get_ioas(access->ictx, ioas_id);

	if (IS_ERR(new_ioas))

		return PTR_ERR(new_ioas);



	rc = iopt_add_access(&new_ioas->iopt, access);

	if (rc) {

		iommufd_put_object(&new_ioas->obj);

		return rc;

	}

	iommufd_ref_to_users(&new_ioas->obj);



	access->ioas = new_ioas;

	return 0;

}

EXPORT_SYMBOL_NS_GPL(iommufd_access_attach, IOMMUFD);



/**

 * iommufd_access_notify_unmap - Notify users of an iopt to stop using it

 * @iopt: iopt to work on
@@ -726,41 +719,3 @@ int iommufd_access_rw(struct iommufd_access *access, unsigned long iova, 
	return rc;

}

EXPORT_SYMBOL_NS_GPL(iommufd_access_rw, IOMMUFD);
 


#ifdef CONFIG_IOMMUFD_TEST

/*

 * Creating a real iommufd_device is too hard, bypass creating a iommufd_device

 * and go directly to attaching a domain.

 */

struct iommufd_hw_pagetable *

iommufd_device_selftest_attach(struct iommufd_ctx *ictx,

			       struct iommufd_ioas *ioas,

			       struct device *mock_dev)

{

	struct iommufd_hw_pagetable *hwpt;

	int rc;



	hwpt = iommufd_hw_pagetable_alloc(ictx, ioas, mock_dev);

	if (IS_ERR(hwpt))

		return hwpt;



	rc = iopt_table_add_domain(&hwpt->ioas->iopt, hwpt->domain);

	if (rc)

		goto out_hwpt;



	refcount_inc(&hwpt->obj.users);

	iommufd_object_finalize(ictx, &hwpt->obj);

	return hwpt;



out_hwpt:

	iommufd_object_abort_and_destroy(ictx, &hwpt->obj);

	return ERR_PTR(rc);

}



void iommufd_device_selftest_detach(struct iommufd_ctx *ictx,

				    struct iommufd_hw_pagetable *hwpt)

{

	iopt_table_remove_domain(&hwpt->ioas->iopt, hwpt->domain);

	refcount_dec(&hwpt->obj.users);

}

#endif

drivers/iommu/iommufd/hw_pagetable.c

+59 −11
Original line number Diff line number Diff line
@@ -13,7 +13,17 @@ void iommufd_hw_pagetable_destroy(struct iommufd_object *obj) 


	WARN_ON(!list_empty(&hwpt->devices));



	if (!list_empty(&hwpt->hwpt_item)) {

		mutex_lock(&hwpt->ioas->mutex);

		list_del(&hwpt->hwpt_item);

		mutex_unlock(&hwpt->ioas->mutex);



		iopt_table_remove_domain(&hwpt->ioas->iopt, hwpt->domain);

	}



	if (hwpt->domain)

		iommu_domain_free(hwpt->domain);



	refcount_dec(&hwpt->ioas->obj.users);

	mutex_destroy(&hwpt->devices_lock);

}
@@ -22,36 +32,74 @@ void iommufd_hw_pagetable_destroy(struct iommufd_object *obj) 
 * iommufd_hw_pagetable_alloc() - Get an iommu_domain for a device

 * @ictx: iommufd context

 * @ioas: IOAS to associate the domain with

 * @dev: Device to get an iommu_domain for

 * @idev: Device to get an iommu_domain for

 * @immediate_attach: True if idev should be attached to the hwpt

 *

 * Allocate a new iommu_domain and return it as a hw_pagetable.

 * Allocate a new iommu_domain and return it as a hw_pagetable. The HWPT

 * will be linked to the given ioas and upon return the underlying iommu_domain

 * is fully popoulated.

 */

struct iommufd_hw_pagetable *

iommufd_hw_pagetable_alloc(struct iommufd_ctx *ictx, struct iommufd_ioas *ioas,

			   struct device *dev)

			   struct iommufd_device *idev, bool immediate_attach)

{

	struct iommufd_hw_pagetable *hwpt;

	int rc;



	lockdep_assert_held(&ioas->mutex);



	hwpt = iommufd_object_alloc(ictx, hwpt, IOMMUFD_OBJ_HW_PAGETABLE);

	if (IS_ERR(hwpt))

		return hwpt;



	hwpt->domain = iommu_domain_alloc(dev->bus);

	if (!hwpt->domain) {

		rc = -ENOMEM;

		goto out_abort;

	}



	INIT_LIST_HEAD(&hwpt->devices);

	INIT_LIST_HEAD(&hwpt->hwpt_item);

	mutex_init(&hwpt->devices_lock);

	/* Pairs with iommufd_hw_pagetable_destroy() */

	refcount_inc(&ioas->obj.users);

	hwpt->ioas = ioas;



	hwpt->domain = iommu_domain_alloc(idev->dev->bus);

	if (!hwpt->domain) {

		rc = -ENOMEM;

		goto out_abort;

	}



	mutex_lock(&hwpt->devices_lock);



	/*

	 * immediate_attach exists only to accommodate iommu drivers that cannot

	 * directly allocate a domain. These drivers do not finish creating the

	 * domain until attach is completed. Thus we must have this call

	 * sequence. Once those drivers are fixed this should be removed.

	 */

	if (immediate_attach) {

		rc = iommufd_hw_pagetable_attach(hwpt, idev);

		if (rc)

			goto out_unlock;

	}



	rc = iopt_table_add_domain(&hwpt->ioas->iopt, hwpt->domain);

	if (rc)

		goto out_detach;

	list_add_tail(&hwpt->hwpt_item, &hwpt->ioas->hwpt_list);



	if (immediate_attach) {

		/* See iommufd_device_do_attach() */

		refcount_inc(&hwpt->obj.users);

		idev->hwpt = hwpt;

		list_add(&idev->devices_item, &hwpt->devices);

	}



	mutex_unlock(&hwpt->devices_lock);

	return hwpt;



out_detach:

	if (immediate_attach)

		iommufd_hw_pagetable_detach(hwpt, idev);

out_unlock:

	mutex_unlock(&hwpt->devices_lock);

out_abort:

	iommufd_object_abort(ictx, &hwpt->obj);

	iommufd_object_abort_and_destroy(ictx, &hwpt->obj);

	return ERR_PTR(rc);

}

drivers/iommu/iommufd/ioas.c

+7 −7
Original line number Diff line number Diff line
@@ -71,7 +71,7 @@ int iommufd_ioas_iova_ranges(struct iommufd_ucmd *ucmd) 
	if (cmd->__reserved)

		return -EOPNOTSUPP;



	ioas = iommufd_get_ioas(ucmd, cmd->ioas_id);

	ioas = iommufd_get_ioas(ucmd->ictx, cmd->ioas_id);

	if (IS_ERR(ioas))

		return PTR_ERR(ioas);
@@ -151,7 +151,7 @@ int iommufd_ioas_allow_iovas(struct iommufd_ucmd *ucmd) 
	if (cmd->__reserved)

		return -EOPNOTSUPP;



	ioas = iommufd_get_ioas(ucmd, cmd->ioas_id);

	ioas = iommufd_get_ioas(ucmd->ictx, cmd->ioas_id);

	if (IS_ERR(ioas))

		return PTR_ERR(ioas);

	iopt = &ioas->iopt;
@@ -213,7 +213,7 @@ int iommufd_ioas_map(struct iommufd_ucmd *ucmd) 
	if (cmd->iova >= ULONG_MAX || cmd->length >= ULONG_MAX)

		return -EOVERFLOW;



	ioas = iommufd_get_ioas(ucmd, cmd->ioas_id);

	ioas = iommufd_get_ioas(ucmd->ictx, cmd->ioas_id);

	if (IS_ERR(ioas))

		return PTR_ERR(ioas);
@@ -253,7 +253,7 @@ int iommufd_ioas_copy(struct iommufd_ucmd *ucmd) 
	    cmd->dst_iova >= ULONG_MAX)

		return -EOVERFLOW;



	src_ioas = iommufd_get_ioas(ucmd, cmd->src_ioas_id);

	src_ioas = iommufd_get_ioas(ucmd->ictx, cmd->src_ioas_id);

	if (IS_ERR(src_ioas))

		return PTR_ERR(src_ioas);

	rc = iopt_get_pages(&src_ioas->iopt, cmd->src_iova, cmd->length,
@@ -262,7 +262,7 @@ int iommufd_ioas_copy(struct iommufd_ucmd *ucmd) 
	if (rc)

		return rc;



	dst_ioas = iommufd_get_ioas(ucmd, cmd->dst_ioas_id);

	dst_ioas = iommufd_get_ioas(ucmd->ictx, cmd->dst_ioas_id);

	if (IS_ERR(dst_ioas)) {

		rc = PTR_ERR(dst_ioas);

		goto out_pages;
@@ -292,7 +292,7 @@ int iommufd_ioas_unmap(struct iommufd_ucmd *ucmd) 
	unsigned long unmapped = 0;

	int rc;



	ioas = iommufd_get_ioas(ucmd, cmd->ioas_id);

	ioas = iommufd_get_ioas(ucmd->ictx, cmd->ioas_id);

	if (IS_ERR(ioas))

		return PTR_ERR(ioas);
@@ -381,7 +381,7 @@ int iommufd_ioas_option(struct iommufd_ucmd *ucmd) 
	if (cmd->__reserved)

		return -EOPNOTSUPP;



	ioas = iommufd_get_ioas(ucmd, cmd->object_id);

	ioas = iommufd_get_ioas(ucmd->ictx, cmd->object_id);

	if (IS_ERR(ioas))

		return PTR_ERR(ioas);

drivers/iommu/iommufd/iommufd_private.h

+30 −9
Original line number Diff line number Diff line
@@ -12,6 +12,7 @@ 
struct iommu_domain;

struct iommu_group;

struct iommu_option;

struct iommufd_device;



struct iommufd_ctx {

	struct file *file;
@@ -211,10 +212,10 @@ struct iommufd_ioas { 
	struct list_head hwpt_list;

};



static inline struct iommufd_ioas *iommufd_get_ioas(struct iommufd_ucmd *ucmd,

static inline struct iommufd_ioas *iommufd_get_ioas(struct iommufd_ctx *ictx,

						    u32 id)

{

	return container_of(iommufd_get_object(ucmd->ictx, id,

	return container_of(iommufd_get_object(ictx, id,

					       IOMMUFD_OBJ_IOAS),

			    struct iommufd_ioas, obj);

}
@@ -254,9 +255,30 @@ struct iommufd_hw_pagetable { 


struct iommufd_hw_pagetable *

iommufd_hw_pagetable_alloc(struct iommufd_ctx *ictx, struct iommufd_ioas *ioas,

			   struct device *dev);

			   struct iommufd_device *idev, bool immediate_attach);

int iommufd_hw_pagetable_attach(struct iommufd_hw_pagetable *hwpt,

				struct iommufd_device *idev);

void iommufd_hw_pagetable_detach(struct iommufd_hw_pagetable *hwpt,

				 struct iommufd_device *idev);

void iommufd_hw_pagetable_destroy(struct iommufd_object *obj);



/*

 * A iommufd_device object represents the binding relationship between a

 * consuming driver and the iommufd. These objects are created/destroyed by

 * external drivers, not by userspace.

 */

struct iommufd_device {

	struct iommufd_object obj;

	struct iommufd_ctx *ictx;

	struct iommufd_hw_pagetable *hwpt;

	/* Head at iommufd_hw_pagetable::devices */

	struct list_head devices_item;

	/* always the physical device */

	struct device *dev;

	struct iommu_group *group;

	bool enforce_cache_coherency;

};



void iommufd_device_destroy(struct iommufd_object *obj);



struct iommufd_access {
@@ -275,12 +297,6 @@ void iopt_remove_access(struct io_pagetable *iopt, 
void iommufd_access_destroy_object(struct iommufd_object *obj);



#ifdef CONFIG_IOMMUFD_TEST

struct iommufd_hw_pagetable *

iommufd_device_selftest_attach(struct iommufd_ctx *ictx,

			       struct iommufd_ioas *ioas,

			       struct device *mock_dev);

void iommufd_device_selftest_detach(struct iommufd_ctx *ictx,

				    struct iommufd_hw_pagetable *hwpt);

int iommufd_test(struct iommufd_ucmd *ucmd);

void iommufd_selftest_destroy(struct iommufd_object *obj);

extern size_t iommufd_test_memory_limit;
@@ -289,6 +305,7 @@ void iommufd_test_syz_conv_iova_id(struct iommufd_ucmd *ucmd, 
bool iommufd_should_fail(void);

void __init iommufd_test_init(void);

void iommufd_test_exit(void);

bool iommufd_selftest_is_mock_dev(struct device *dev);

#else

static inline void iommufd_test_syz_conv_iova_id(struct iommufd_ucmd *ucmd,

						 unsigned int ioas_id,
@@ -305,5 +322,9 @@ static inline void __init iommufd_test_init(void) 
static inline void iommufd_test_exit(void)

{

}

static inline bool iommufd_selftest_is_mock_dev(struct device *dev)

{

	return false;

}

#endif

#endif

drivers/iommu/iommufd/iommufd_test.h

+1 −1
Original line number Diff line number Diff line
@@ -49,7 +49,7 @@ struct iommu_test_cmd { 
			__aligned_u64 length;

		} add_reserved;

		struct {

			__u32 out_device_id;

			__u32 out_stdev_id;

			__u32 out_hwpt_id;

		} mock_domain;

		struct {