In preparation for the asynchronous VM_BIND that follows. Why DRM_GPUVM_IMMEDIATE_MODE is needed:
Running binds from a async-job makes a deadlock. run_job() takes a BO's dma_resv to update that BO's gpuva list, and has to signal a fence once done(=signalling section). Another thread can be holding the same dma_resv while waiting on that fence, so the two wait on each other. Switching to DRM_GPUVM_IMMEDIATE_MODE requires two things: 1. Drop drm_gpuvm_exec. It calls dma_resv_lock() internally, which is the path that deadlocks. It did also serve as the address space tree lock, so take pvr_vm_context::lock explicitly instead. 2. Let the GEM's gpuva.lock protect the list. That lock is only ever held across list surgery, so no fence waiter can be holding it. Panthor went this way first, for the same reason. No functional change intended. Signed-off-by: Gyeyoung Baek <[email protected]> --- drivers/gpu/drm/imagination/pvr_vm.c | 80 +++++++++++++----------------------- 1 file changed, 29 insertions(+), 51 deletions(-) diff --git a/drivers/gpu/drm/imagination/pvr_vm.c b/drivers/gpu/drm/imagination/pvr_vm.c index 608e8c0467d..45df76e61f7 100644 --- a/drivers/gpu/drm/imagination/pvr_vm.c +++ b/drivers/gpu/drm/imagination/pvr_vm.c @@ -214,7 +214,7 @@ static int pvr_vm_bind_op_exec(struct pvr_vm_bind_op *bind_op) static void pvr_vm_bind_op_fini(struct pvr_vm_bind_op *bind_op) { - drm_gpuvm_bo_put(bind_op->gpuvm_bo); + drm_gpuvm_bo_put_deferred(bind_op->gpuvm_bo); kfree(bind_op->new_va); kfree(bind_op->prev_va); @@ -255,11 +255,11 @@ pvr_vm_bind_op_map_init(struct pvr_vm_bind_op *bind_op, bind_op->type = PVR_VM_BIND_TYPE_MAP; - dma_resv_lock(obj->resv, NULL); - bind_op->gpuvm_bo = drm_gpuvm_bo_obtain_locked(&vm_ctx->gpuvm_mgr, obj); - dma_resv_unlock(obj->resv); - if (IS_ERR(bind_op->gpuvm_bo)) - return PTR_ERR(bind_op->gpuvm_bo); + bind_op->gpuvm_bo = drm_gpuvm_bo_create(&vm_ctx->gpuvm_mgr, obj); + if (!bind_op->gpuvm_bo) + return -ENOMEM; + + bind_op->gpuvm_bo = drm_gpuvm_bo_obtain_prealloc(bind_op->gpuvm_bo); bind_op->new_va = kzalloc_obj(*bind_op->new_va); bind_op->prev_va = kzalloc_obj(*bind_op->prev_va); @@ -366,7 +366,11 @@ pvr_vm_gpuva_map(struct drm_gpuva_op *op, void *op_ctx) return err; drm_gpuva_map(&ctx->vm_ctx->gpuvm_mgr, &ctx->new_va->base, &op->map); + + mutex_lock(&op->map.gem.obj->gpuva.lock); drm_gpuva_link(&ctx->new_va->base, ctx->gpuvm_bo); + mutex_unlock(&op->map.gem.obj->gpuva.lock); + ctx->new_va = NULL; return 0; @@ -396,7 +400,7 @@ pvr_vm_gpuva_unmap(struct drm_gpuva_op *op, void *op_ctx) return err; drm_gpuva_unmap(&op->unmap); - drm_gpuva_unlink(op->unmap.va); + drm_gpuva_unlink_defer(op->unmap.va); kfree(to_pvr_vm_gpuva(op->unmap.va)); return 0; @@ -419,6 +423,7 @@ static int pvr_vm_gpuva_remap(struct drm_gpuva_op *op, void *op_ctx) { struct drm_gpuva *unmap_va = op->remap.unmap->va; + struct drm_gem_object *obj = unmap_va->gem.obj; struct drm_gpuvm_bo *vm_bo = unmap_va->vm_bo; struct pvr_vm_bind_op *ctx = op_ctx; u64 va_start = 0, va_range = 0; @@ -436,17 +441,21 @@ pvr_vm_gpuva_remap(struct drm_gpuva_op *op, void *op_ctx) if (op->remap.prev) { pvr_gem_object_get(gem_to_pvr_gem(ctx->prev_va->base.gem.obj)); + mutex_lock(&obj->gpuva.lock); drm_gpuva_link(&ctx->prev_va->base, vm_bo); + mutex_unlock(&obj->gpuva.lock); ctx->prev_va = NULL; } if (op->remap.next) { pvr_gem_object_get(gem_to_pvr_gem(ctx->next_va->base.gem.obj)); + mutex_lock(&obj->gpuva.lock); drm_gpuva_link(&ctx->next_va->base, vm_bo); + mutex_unlock(&obj->gpuva.lock); ctx->next_va = NULL; } - drm_gpuva_unlink(unmap_va); + drm_gpuva_unlink_defer(unmap_va); kfree(to_pvr_vm_gpuva(unmap_va)); return 0; @@ -590,7 +599,8 @@ pvr_vm_create_context(struct pvr_device *pvr_dev, bool is_userspace_context) drm_gem_private_object_init(&pvr_dev->base, &vm_ctx->dummy_gem, 0); drm_gpuvm_init(&vm_ctx->gpuvm_mgr, is_userspace_context ? "PowerVR-user-VM" : "PowerVR-FW-VM", - 0, &pvr_dev->base, &vm_ctx->dummy_gem, + DRM_GPUVM_IMMEDIATE_MODE, &pvr_dev->base, + &vm_ctx->dummy_gem, 0, 1ULL << device_addr_bits, 0, 0, &pvr_vm_gpuva_ops); mutex_init(&vm_ctx->lock); @@ -624,6 +634,7 @@ pvr_vm_context_release(struct kref *ref_count) pvr_fw_object_destroy(vm_ctx->fw_mem_ctx_obj); pvr_vm_unmap_all(vm_ctx); + drm_gpuvm_bo_deferred_cleanup(&vm_ctx->gpuvm_mgr); pvr_mmu_context_destroy(vm_ctx->mmu_ctx); drm_gem_private_object_fini(&vm_ctx->dummy_gem); @@ -693,16 +704,6 @@ void pvr_destroy_vm_contexts_for_file(struct pvr_file *pvr_file) } } -static int -pvr_vm_lock_extra(struct drm_gpuvm_exec *vm_exec) -{ - struct pvr_vm_bind_op *bind_op = vm_exec->extra.priv; - struct pvr_gem_object *pvr_obj = bind_op->pvr_obj; - - /* Acquire lock on the GEM object being mapped/unmapped. */ - return drm_exec_lock_obj(&vm_exec->exec, gem_from_pvr_gem(pvr_obj)); -} - /** * pvr_vm_map() - Map a section of physical memory into a section of * device-virtual memory. @@ -730,15 +731,6 @@ pvr_vm_map(struct pvr_vm_context *vm_ctx, struct pvr_gem_object *pvr_obj, u64 pvr_obj_offset, u64 device_addr, u64 size) { struct pvr_vm_bind_op bind_op = {0}; - struct drm_gpuvm_exec vm_exec = { - .vm = &vm_ctx->gpuvm_mgr, - .flags = DRM_EXEC_INTERRUPTIBLE_WAIT | - DRM_EXEC_IGNORE_DUPLICATES, - .extra = { - .fn = pvr_vm_lock_extra, - .priv = &bind_op, - }, - }; int err = pvr_vm_bind_op_map_init(&bind_op, vm_ctx, pvr_obj, pvr_obj_offset, device_addr, @@ -749,16 +741,12 @@ pvr_vm_map(struct pvr_vm_context *vm_ctx, struct pvr_gem_object *pvr_obj, pvr_gem_object_get(pvr_obj); - err = drm_gpuvm_exec_lock(&vm_exec); - if (err) - goto err_cleanup; - + mutex_lock(&vm_ctx->lock); err = pvr_vm_bind_op_exec(&bind_op); + mutex_unlock(&vm_ctx->lock); - drm_gpuvm_exec_unlock(&vm_exec); - -err_cleanup: pvr_vm_bind_op_fini(&bind_op); + drm_gpuvm_bo_deferred_cleanup(&vm_ctx->gpuvm_mgr); return err; } @@ -787,15 +775,6 @@ pvr_vm_unmap_obj_locked(struct pvr_vm_context *vm_ctx, u64 device_addr, u64 size) { struct pvr_vm_bind_op bind_op = {0}; - struct drm_gpuvm_exec vm_exec = { - .vm = &vm_ctx->gpuvm_mgr, - .flags = DRM_EXEC_INTERRUPTIBLE_WAIT | - DRM_EXEC_IGNORE_DUPLICATES, - .extra = { - .fn = pvr_vm_lock_extra, - .priv = &bind_op, - }, - }; int err = pvr_vm_bind_op_unmap_init(&bind_op, vm_ctx, pvr_obj, device_addr, size); @@ -804,15 +783,8 @@ pvr_vm_unmap_obj_locked(struct pvr_vm_context *vm_ctx, pvr_gem_object_get(pvr_obj); - err = drm_gpuvm_exec_lock(&vm_exec); - if (err) - goto err_cleanup; - err = pvr_vm_bind_op_exec(&bind_op); - drm_gpuvm_exec_unlock(&vm_exec); - -err_cleanup: pvr_vm_bind_op_fini(&bind_op); return err; @@ -840,6 +812,8 @@ pvr_vm_unmap_obj(struct pvr_vm_context *vm_ctx, struct pvr_gem_object *pvr_obj, err = pvr_vm_unmap_obj_locked(vm_ctx, pvr_obj, device_addr, size); mutex_unlock(&vm_ctx->lock); + drm_gpuvm_bo_deferred_cleanup(&vm_ctx->gpuvm_mgr); + return err; } @@ -874,6 +848,8 @@ pvr_vm_unmap(struct pvr_vm_context *vm_ctx, u64 device_addr, u64 size) mutex_unlock(&vm_ctx->lock); + drm_gpuvm_bo_deferred_cleanup(&vm_ctx->gpuvm_mgr); + return err; } @@ -906,6 +882,8 @@ pvr_vm_unmap_all(struct pvr_vm_context *vm_ctx) } mutex_unlock(&vm_ctx->lock); + + drm_gpuvm_bo_deferred_cleanup(&vm_ctx->gpuvm_mgr); } /* Static data areas are determined by firmware. */ -- 2.43.0
