Commit 4ca06f6f authored by Tvrtko Ursulin's avatar Tvrtko Ursulin Committed by Alex Deucher
Browse files

drm/amdgpu/userq: Use drm_gem_objects_lookup in amdgpu_userq_signal_ioctl 



Use the existing helper instead of open coding it.

Signed-off-by: default avatarTvrtko Ursulin <tvrtko.ursulin@igalia.com>
Reviewed-by: default avatarSunil Khatri <sunil.khatrti@amd.com>
Signed-off-by: default avatarAlex Deucher <alexander.deucher@amd.com>
parent cb48a6b2

drivers/gpu/drm/amd/amdgpu/amdgpu_userq_fence.c

+21 −58
Original line number Diff line number Diff line
@@ -459,20 +459,19 @@ int amdgpu_userq_signal_ioctl(struct drm_device *dev, void *data, 
			      struct drm_file *filp)

{

	struct amdgpu_device *adev = drm_to_adev(dev);

	struct drm_amdgpu_userq_signal *args = data;

	const unsigned int num_write_bo_handles = args->num_bo_write_handles;

	const unsigned int num_read_bo_handles = args->num_bo_read_handles;

	struct amdgpu_fpriv *fpriv = filp->driver_priv;

	struct amdgpu_userq_mgr *userq_mgr = &fpriv->userq_mgr;

	struct drm_amdgpu_userq_signal *args = data;

	struct drm_gem_object **gobj_write = NULL;

	struct drm_gem_object **gobj_read = NULL;

	struct amdgpu_usermode_queue *queue;

	struct drm_gem_object **gobj_write, **gobj_read;

	u32 *syncobj_handles, num_syncobj_handles;

	struct amdgpu_userq_fence *userq_fence;

	struct amdgpu_usermode_queue *queue;

	struct drm_syncobj **syncobj = NULL;

	u32 *bo_handles_write, num_write_bo_handles;

	u32 *syncobj_handles, num_syncobj_handles;

	u32 *bo_handles_read, num_read_bo_handles;

	int r, i, entry, rentry, wentry;

	struct dma_fence *fence;

	struct drm_exec exec;

	int r, i, entry;

	u64 wptr;



	if (!amdgpu_userq_enabled(dev))
@@ -499,51 +498,19 @@ int amdgpu_userq_signal_ioctl(struct drm_device *dev, void *data, 
		}

	}



	num_read_bo_handles = args->num_bo_read_handles;

	bo_handles_read = memdup_user(u64_to_user_ptr(args->bo_read_handles),

				      sizeof(u32) * num_read_bo_handles);

	if (IS_ERR(bo_handles_read)) {

		r = PTR_ERR(bo_handles_read);

	r = drm_gem_objects_lookup(filp,

				   u64_to_user_ptr(args->bo_read_handles),

				   num_read_bo_handles,

				   &gobj_read);

	if (r)

		goto free_syncobj;

	}



	/* Array of pointers to the GEM read objects */

	gobj_read = kmalloc_array(num_read_bo_handles, sizeof(*gobj_read), GFP_KERNEL);

	if (!gobj_read) {

		r = -ENOMEM;

		goto free_bo_handles_read;

	}



	for (rentry = 0; rentry < num_read_bo_handles; rentry++) {

		gobj_read[rentry] = drm_gem_object_lookup(filp, bo_handles_read[rentry]);

		if (!gobj_read[rentry]) {

			r = -ENOENT;

			goto put_gobj_read;

		}

	}



	num_write_bo_handles = args->num_bo_write_handles;

	bo_handles_write = memdup_user(u64_to_user_ptr(args->bo_write_handles),

				       sizeof(u32) * num_write_bo_handles);

	if (IS_ERR(bo_handles_write)) {

		r = PTR_ERR(bo_handles_write);

	r = drm_gem_objects_lookup(filp,

				   u64_to_user_ptr(args->bo_write_handles),

				   num_write_bo_handles,

				   &gobj_write);

	if (r)

		goto put_gobj_read;

	}



	/* Array of pointers to the GEM write objects */

	gobj_write = kmalloc_array(num_write_bo_handles, sizeof(*gobj_write), GFP_KERNEL);

	if (!gobj_write) {

		r = -ENOMEM;

		goto free_bo_handles_write;

	}



	for (wentry = 0; wentry < num_write_bo_handles; wentry++) {

		gobj_write[wentry] = drm_gem_object_lookup(filp, bo_handles_write[wentry]);

		if (!gobj_write[wentry]) {

			r = -ENOENT;

			goto put_gobj_write;

		}

	}



	/* Retrieve the user queue */

	queue = xa_load(&userq_mgr->userq_xa, args->queue_id);
@@ -622,17 +589,13 @@ int amdgpu_userq_signal_ioctl(struct drm_device *dev, void *data, 
exec_fini:

	drm_exec_fini(&exec);

put_gobj_write:

	while (wentry-- > 0)

		drm_gem_object_put(gobj_write[wentry]);

	for (i = 0; i < num_write_bo_handles; i++)

		drm_gem_object_put(gobj_write[i]);

	kfree(gobj_write);

free_bo_handles_write:

	kfree(bo_handles_write);

put_gobj_read:

	while (rentry-- > 0)

		drm_gem_object_put(gobj_read[rentry]);

	for (i = 0; i < num_read_bo_handles; i++)

		drm_gem_object_put(gobj_read[i]);

	kfree(gobj_read);

free_bo_handles_read:

	kfree(bo_handles_read);

free_syncobj:

	while (entry-- > 0)

		if (syncobj[entry])