Commit 421cfe65 authored by Matthew Rosato's avatar Matthew Rosato Committed by Alex Williamson
Browse files

vfio: remove VFIO_GROUP_NOTIFY_SET_KVM 



Rather than relying on a notifier for associating the KVM with
the group, let's assume that the association has already been
made prior to device_open.  The first time a device is opened
associate the group KVM with the device.

This fixes a user-triggerable oops in GVT.

Reviewed-by: default avatarTony Krowiak <akrowiak@linux.ibm.com>
Reviewed-by: default avatarKevin Tian <kevin.tian@intel.com>
Reviewed-by: default avatarChristoph Hellwig <hch@lst.de>
Signed-off-by: default avatarJason Gunthorpe <jgg@nvidia.com>
Signed-off-by: default avatarMatthew Rosato <mjrosato@linux.ibm.com>
Reviewed-by: default avatarJason Gunthorpe <jgg@nvidia.com>
Acked-by: default avatarZhi Wang <zhi.a.wang@intel.com>
Link: https://lore.kernel.org/r/20220519183311.582380-2-mjrosato@linux.ibm.com


Signed-off-by: default avatarAlex Williamson <alex.williamson@redhat.com>
parent c490513c

drivers/gpu/drm/i915/gvt/gtt.c

+2 −2
Original line number Diff line number Diff line
@@ -51,7 +51,7 @@ static int preallocated_oos_pages = 8192; 


static bool intel_gvt_is_valid_gfn(struct intel_vgpu *vgpu, unsigned long gfn)

{

	struct kvm *kvm = vgpu->kvm;

	struct kvm *kvm = vgpu->vfio_device.kvm;

	int idx;

	bool ret;
@@ -1185,7 +1185,7 @@ static int is_2MB_gtt_possible(struct intel_vgpu *vgpu, 


	if (!vgpu->attached)

		return -EINVAL;

	pfn = gfn_to_pfn(vgpu->kvm, ops->get_pfn(entry));

	pfn = gfn_to_pfn(vgpu->vfio_device.kvm, ops->get_pfn(entry));

	if (is_error_noslot_pfn(pfn))

		return -EINVAL;

	return PageTransHuge(pfn_to_page(pfn));

drivers/gpu/drm/i915/gvt/gvt.h

+0 −3
Original line number Diff line number Diff line
@@ -227,9 +227,6 @@ struct intel_vgpu { 
	struct mutex cache_lock;



	struct notifier_block iommu_notifier;

	struct notifier_block group_notifier;

	struct kvm *kvm;

	struct work_struct release_work;

	atomic_t released;



	struct kvm_page_track_notifier_node track_node;

drivers/gpu/drm/i915/gvt/kvmgt.c

+18 −64
Original line number Diff line number Diff line
@@ -228,8 +228,6 @@ static void intel_gvt_cleanup_vgpu_type_groups(struct intel_gvt *gvt) 
	}

}



static void intel_vgpu_release_work(struct work_struct *work);



static void gvt_unpin_guest_page(struct intel_vgpu *vgpu, unsigned long gfn,

		unsigned long size)

{
@@ -761,23 +759,6 @@ static int intel_vgpu_iommu_notifier(struct notifier_block *nb, 
	return NOTIFY_OK;

}



static int intel_vgpu_group_notifier(struct notifier_block *nb,

				     unsigned long action, void *data)

{

	struct intel_vgpu *vgpu =

		container_of(nb, struct intel_vgpu, group_notifier);



	/* the only action we care about */

	if (action == VFIO_GROUP_NOTIFY_SET_KVM) {

		vgpu->kvm = data;



		if (!data)

			schedule_work(&vgpu->release_work);

	}



	return NOTIFY_OK;

}



static bool __kvmgt_vgpu_exist(struct intel_vgpu *vgpu)

{

	struct intel_vgpu *itr;
@@ -789,7 +770,7 @@ static bool __kvmgt_vgpu_exist(struct intel_vgpu *vgpu) 
		if (!itr->attached)

			continue;



		if (vgpu->kvm == itr->kvm) {

		if (vgpu->vfio_device.kvm == itr->vfio_device.kvm) {

			ret = true;

			goto out;

		}
@@ -806,7 +787,6 @@ static int intel_vgpu_open_device(struct vfio_device *vfio_dev) 
	int ret;



	vgpu->iommu_notifier.notifier_call = intel_vgpu_iommu_notifier;

	vgpu->group_notifier.notifier_call = intel_vgpu_group_notifier;



	events = VFIO_IOMMU_NOTIFY_DMA_UNMAP;

	ret = vfio_register_notifier(vfio_dev, VFIO_IOMMU_NOTIFY, &events,
@@ -817,38 +797,32 @@ static int intel_vgpu_open_device(struct vfio_device *vfio_dev) 
		goto out;

	}



	events = VFIO_GROUP_NOTIFY_SET_KVM;

	ret = vfio_register_notifier(vfio_dev, VFIO_GROUP_NOTIFY, &events,

				     &vgpu->group_notifier);

	if (ret != 0) {

		gvt_vgpu_err("vfio_register_notifier for group failed: %d\n",

			ret);

		goto undo_iommu;

	}



	ret = -EEXIST;

	if (vgpu->attached)

		goto undo_register;

		goto undo_iommu;



	ret = -ESRCH;

	if (!vgpu->kvm || vgpu->kvm->mm != current->mm) {

	if (!vgpu->vfio_device.kvm ||

	    vgpu->vfio_device.kvm->mm != current->mm) {

		gvt_vgpu_err("KVM is required to use Intel vGPU\n");

		goto undo_register;

		goto undo_iommu;

	}



	kvm_get_kvm(vgpu->vfio_device.kvm);



	ret = -EEXIST;

	if (__kvmgt_vgpu_exist(vgpu))

		goto undo_register;

		goto undo_iommu;



	vgpu->attached = true;

	kvm_get_kvm(vgpu->kvm);



	kvmgt_protect_table_init(vgpu);

	gvt_cache_init(vgpu);



	vgpu->track_node.track_write = kvmgt_page_track_write;

	vgpu->track_node.track_flush_slot = kvmgt_page_track_flush_slot;

	kvm_page_track_register_notifier(vgpu->kvm, &vgpu->track_node);

	kvm_page_track_register_notifier(vgpu->vfio_device.kvm,

					 &vgpu->track_node);



	debugfs_create_ulong(KVMGT_DEBUGFS_FILENAME, 0444, vgpu->debugfs,

			     &vgpu->nr_cache_entries);
@@ -858,10 +832,6 @@ static int intel_vgpu_open_device(struct vfio_device *vfio_dev) 
	atomic_set(&vgpu->released, 0);

	return 0;



undo_register:

	vfio_unregister_notifier(vfio_dev, VFIO_GROUP_NOTIFY,

				 &vgpu->group_notifier);



undo_iommu:

	vfio_unregister_notifier(vfio_dev, VFIO_IOMMU_NOTIFY,

				 &vgpu->iommu_notifier);
@@ -880,8 +850,9 @@ static void intel_vgpu_release_msi_eventfd_ctx(struct intel_vgpu *vgpu) 
	}

}



static void __intel_vgpu_release(struct intel_vgpu *vgpu)

static void intel_vgpu_close_device(struct vfio_device *vfio_dev)

{

	struct intel_vgpu *vgpu = vfio_dev_to_vgpu(vfio_dev);

	struct drm_i915_private *i915 = vgpu->gvt->gt->i915;

	int ret;
@@ -898,35 +869,19 @@ static void __intel_vgpu_release(struct intel_vgpu *vgpu) 
	drm_WARN(&i915->drm, ret,

		 "vfio_unregister_notifier for iommu failed: %d\n", ret);



	ret = vfio_unregister_notifier(&vgpu->vfio_device, VFIO_GROUP_NOTIFY,

				       &vgpu->group_notifier);

	drm_WARN(&i915->drm, ret,

		 "vfio_unregister_notifier for group failed: %d\n", ret);



	debugfs_remove(debugfs_lookup(KVMGT_DEBUGFS_FILENAME, vgpu->debugfs));



	kvm_page_track_unregister_notifier(vgpu->kvm, &vgpu->track_node);

	kvm_put_kvm(vgpu->kvm);

	kvm_page_track_unregister_notifier(vgpu->vfio_device.kvm,

					   &vgpu->track_node);

	kvmgt_protect_table_destroy(vgpu);

	gvt_cache_destroy(vgpu);



	intel_vgpu_release_msi_eventfd_ctx(vgpu);



	vgpu->kvm = NULL;

	vgpu->attached = false;

}



static void intel_vgpu_close_device(struct vfio_device *vfio_dev)

{

	__intel_vgpu_release(vfio_dev_to_vgpu(vfio_dev));

}



static void intel_vgpu_release_work(struct work_struct *work)

{

	struct intel_vgpu *vgpu =

		container_of(work, struct intel_vgpu, release_work);



	__intel_vgpu_release(vgpu);

	if (vgpu->vfio_device.kvm)

		kvm_put_kvm(vgpu->vfio_device.kvm);

}



static u64 intel_vgpu_get_bar_addr(struct intel_vgpu *vgpu, int bar)
@@ -1675,7 +1630,6 @@ static int intel_vgpu_probe(struct mdev_device *mdev) 
		return PTR_ERR(vgpu);

	}



	INIT_WORK(&vgpu->release_work, intel_vgpu_release_work);

	vfio_init_group_dev(&vgpu->vfio_device, &mdev->dev,

			    &intel_vgpu_dev_ops);
@@ -1713,7 +1667,7 @@ static struct mdev_driver intel_vgpu_mdev_driver = { 


int intel_gvt_page_track_add(struct intel_vgpu *info, u64 gfn)

{

	struct kvm *kvm = info->kvm;

	struct kvm *kvm = info->vfio_device.kvm;

	struct kvm_memory_slot *slot;

	int idx;
@@ -1743,7 +1697,7 @@ int intel_gvt_page_track_add(struct intel_vgpu *info, u64 gfn) 


int intel_gvt_page_track_remove(struct intel_vgpu *info, u64 gfn)

{

	struct kvm *kvm = info->kvm;

	struct kvm *kvm = info->vfio_device.kvm;

	struct kvm_memory_slot *slot;

	int idx;

drivers/s390/crypto/vfio_ap_ops.c

+6 −29
Original line number Diff line number Diff line
@@ -1284,25 +1284,6 @@ static void vfio_ap_mdev_unset_kvm(struct ap_matrix_mdev *matrix_mdev) 
	}

}



static int vfio_ap_mdev_group_notifier(struct notifier_block *nb,

				       unsigned long action, void *data)

{

	int notify_rc = NOTIFY_OK;

	struct ap_matrix_mdev *matrix_mdev;



	if (action != VFIO_GROUP_NOTIFY_SET_KVM)

		return NOTIFY_OK;



	matrix_mdev = container_of(nb, struct ap_matrix_mdev, group_notifier);



	if (!data)

		vfio_ap_mdev_unset_kvm(matrix_mdev);

	else if (vfio_ap_mdev_set_kvm(matrix_mdev, data))

		notify_rc = NOTIFY_DONE;



	return notify_rc;

}



static struct vfio_ap_queue *vfio_ap_find_queue(int apqn)

{

	struct device *dev;
@@ -1402,11 +1383,10 @@ static int vfio_ap_mdev_open_device(struct vfio_device *vdev) 
	unsigned long events;

	int ret;



	matrix_mdev->group_notifier.notifier_call = vfio_ap_mdev_group_notifier;

	events = VFIO_GROUP_NOTIFY_SET_KVM;

	if (!vdev->kvm)

		return -EINVAL;



	ret = vfio_register_notifier(vdev, VFIO_GROUP_NOTIFY, &events,

				     &matrix_mdev->group_notifier);

	ret = vfio_ap_mdev_set_kvm(matrix_mdev, vdev->kvm);

	if (ret)

		return ret;
@@ -1415,12 +1395,11 @@ static int vfio_ap_mdev_open_device(struct vfio_device *vdev) 
	ret = vfio_register_notifier(vdev, VFIO_IOMMU_NOTIFY, &events,

				     &matrix_mdev->iommu_notifier);

	if (ret)

		goto out_unregister_group;

		goto err_kvm;

	return 0;



out_unregister_group:

	vfio_unregister_notifier(vdev, VFIO_GROUP_NOTIFY,

				 &matrix_mdev->group_notifier);

err_kvm:

	vfio_ap_mdev_unset_kvm(matrix_mdev);

	return ret;

}
@@ -1431,8 +1410,6 @@ static void vfio_ap_mdev_close_device(struct vfio_device *vdev) 


	vfio_unregister_notifier(vdev, VFIO_IOMMU_NOTIFY,

				 &matrix_mdev->iommu_notifier);

	vfio_unregister_notifier(vdev, VFIO_GROUP_NOTIFY,

				 &matrix_mdev->group_notifier);

	vfio_ap_mdev_unset_kvm(matrix_mdev);

}

drivers/s390/crypto/vfio_ap_private.h

+0 −3
Original line number Diff line number Diff line
@@ -81,8 +81,6 @@ struct ap_matrix { 
 * @node:	allows the ap_matrix_mdev struct to be added to a list

 * @matrix:	the adapters, usage domains and control domains assigned to the

 *		mediated matrix device.

 * @group_notifier: notifier block used for specifying callback function for

 *		    handling the VFIO_GROUP_NOTIFY_SET_KVM event

 * @iommu_notifier: notifier block used for specifying callback function for

 *		    handling the VFIO_IOMMU_NOTIFY_DMA_UNMAP even

 * @kvm:	the struct holding guest's state
@@ -94,7 +92,6 @@ struct ap_matrix_mdev { 
	struct vfio_device vdev;

	struct list_head node;

	struct ap_matrix matrix;

	struct notifier_block group_notifier;

	struct notifier_block iommu_notifier;

	struct kvm *kvm;

	crypto_hook pqap_hook;