diff options
Diffstat (limited to 'common/recipes-kernel/linux/linux-yocto-4.14.71/4505-drm-amdgpu-rework-VM-state-machine-lock-handling-v2.patch')
-rw-r--r-- | common/recipes-kernel/linux/linux-yocto-4.14.71/4505-drm-amdgpu-rework-VM-state-machine-lock-handling-v2.patch | 299 |
1 files changed, 299 insertions, 0 deletions
diff --git a/common/recipes-kernel/linux/linux-yocto-4.14.71/4505-drm-amdgpu-rework-VM-state-machine-lock-handling-v2.patch b/common/recipes-kernel/linux/linux-yocto-4.14.71/4505-drm-amdgpu-rework-VM-state-machine-lock-handling-v2.patch new file mode 100644 index 00000000..5cbd53ed --- /dev/null +++ b/common/recipes-kernel/linux/linux-yocto-4.14.71/4505-drm-amdgpu-rework-VM-state-machine-lock-handling-v2.patch @@ -0,0 +1,299 @@ +From 28e3a7d57dba306b92dd09cf999e0cad064fcbf5 Mon Sep 17 00:00:00 2001 +From: christian koenig <christian.koenig@amd.com> +Date: Thu, 19 Apr 2018 10:56:02 +0200 +Subject: [PATCH 4505/5725] drm/amdgpu: rework VM state machine lock handling + v2 +MIME-Version: 1.0 +Content-Type: text/plain; charset=UTF-8 +Content-Transfer-Encoding: 8bit + +Only the moved state needs a separate spin lock protection. All other +states are protected by reserving the VM anyway. + +v2: fix some more incorrect cases + +Change-Id: I9cd5f107c46eea80091f8366234a6c3fb6f508be +Signed-off-by: Christian König <christian.koenig@amd.com> +Reviewed-by: Chunming Zhou <david1.zhou@amd.com> +Signed-off-by: Kalyan Alle <kalyan.alle@amd.com> +--- + drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c | 66 +++++++++++----------------------- + drivers/gpu/drm/amd/amdgpu/amdgpu_vm.h | 4 +-- + 2 files changed, 21 insertions(+), 49 deletions(-) + +diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c b/drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c +index caf5f61..048e39e 100644 +--- a/drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c ++++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c +@@ -119,9 +119,7 @@ static void amdgpu_vm_bo_base_init(struct amdgpu_vm_bo_base *base, + * is currently evicted. add the bo to the evicted list to make sure it + * is validated on next vm use to avoid fault. + * */ +- spin_lock(&vm->status_lock); + list_move_tail(&base->vm_status, &vm->evicted); +- spin_unlock(&vm->status_lock); + } + + /** +@@ -228,7 +226,6 @@ int amdgpu_vm_validate_pt_bos(struct amdgpu_device *adev, struct amdgpu_vm *vm, + struct ttm_bo_global *glob = adev->mman.bdev.glob; + int r; + +- spin_lock(&vm->status_lock); + while (!list_empty(&vm->evicted)) { + struct amdgpu_vm_bo_base *bo_base; + struct amdgpu_bo *bo; +@@ -236,10 +233,8 @@ int amdgpu_vm_validate_pt_bos(struct amdgpu_device *adev, struct amdgpu_vm *vm, + bo_base = list_first_entry(&vm->evicted, + struct amdgpu_vm_bo_base, + vm_status); +- spin_unlock(&vm->status_lock); + + bo = bo_base->bo; +- BUG_ON(!bo); + if (bo->parent) { + r = validate(param, bo); + if (r) +@@ -259,13 +254,14 @@ int amdgpu_vm_validate_pt_bos(struct amdgpu_device *adev, struct amdgpu_vm *vm, + return r; + } + +- spin_lock(&vm->status_lock); +- if (bo->tbo.type != ttm_bo_type_kernel) ++ if (bo->tbo.type != ttm_bo_type_kernel) { ++ spin_lock(&vm->moved_lock); + list_move(&bo_base->vm_status, &vm->moved); +- else ++ spin_unlock(&vm->moved_lock); ++ } else { + list_move(&bo_base->vm_status, &vm->relocated); ++ } + } +- spin_unlock(&vm->status_lock); + + return 0; + } +@@ -279,13 +275,7 @@ int amdgpu_vm_validate_pt_bos(struct amdgpu_device *adev, struct amdgpu_vm *vm, + */ + bool amdgpu_vm_ready(struct amdgpu_vm *vm) + { +- bool ready; +- +- spin_lock(&vm->status_lock); +- ready = list_empty(&vm->evicted); +- spin_unlock(&vm->status_lock); +- +- return ready; ++ return list_empty(&vm->evicted); + } + + /** +@@ -478,9 +468,7 @@ static int amdgpu_vm_alloc_levels(struct amdgpu_device *adev, + pt->parent = amdgpu_bo_ref(parent->base.bo); + + amdgpu_vm_bo_base_init(&entry->base, vm, pt); +- spin_lock(&vm->status_lock); + list_move(&entry->base.vm_status, &vm->relocated); +- spin_unlock(&vm->status_lock); + } + + if (level < AMDGPU_VM_PTB) { +@@ -927,10 +915,8 @@ static void amdgpu_vm_invalidate_level(struct amdgpu_device *adev, + if (!entry->base.bo) + continue; + +- spin_lock(&vm->status_lock); + if (list_empty(&entry->base.vm_status)) + list_add(&entry->base.vm_status, &vm->relocated); +- spin_unlock(&vm->status_lock); + amdgpu_vm_invalidate_level(adev, vm, entry, level + 1); + } + } +@@ -975,7 +961,6 @@ int amdgpu_vm_update_directories(struct amdgpu_device *adev, + params.func = amdgpu_vm_do_set_ptes; + } + +- spin_lock(&vm->status_lock); + while (!list_empty(&vm->relocated)) { + struct amdgpu_vm_bo_base *bo_base, *parent; + struct amdgpu_vm_pt *pt, *entry; +@@ -985,13 +970,10 @@ int amdgpu_vm_update_directories(struct amdgpu_device *adev, + struct amdgpu_vm_bo_base, + vm_status); + list_del_init(&bo_base->vm_status); +- spin_unlock(&vm->status_lock); + + bo = bo_base->bo->parent; +- if (!bo) { +- spin_lock(&vm->status_lock); ++ if (!bo) + continue; +- } + + parent = list_first_entry(&bo->va, struct amdgpu_vm_bo_base, + bo_list); +@@ -1000,12 +982,10 @@ int amdgpu_vm_update_directories(struct amdgpu_device *adev, + + amdgpu_vm_update_pde(¶ms, vm, pt, entry); + +- spin_lock(&vm->status_lock); + if (!vm->use_cpu_for_update && + (ndw - params.ib->length_dw) < 32) + break; + } +- spin_unlock(&vm->status_lock); + + if (vm->use_cpu_for_update) { + /* Flush HDP */ +@@ -1108,9 +1088,7 @@ static void amdgpu_vm_handle_huge_pages(struct amdgpu_pte_update_params *p, + if (entry->huge) { + /* Add the entry to the relocated list to update it. */ + entry->huge = false; +- spin_lock(&p->vm->status_lock); + list_move(&entry->base.vm_status, &p->vm->relocated); +- spin_unlock(&p->vm->status_lock); + } + return; + } +@@ -1618,8 +1596,9 @@ int amdgpu_vm_bo_update(struct amdgpu_device *adev, + amdgpu_asic_flush_hdp(adev, NULL); + } + +- spin_lock(&vm->status_lock); ++ spin_lock(&vm->moved_lock); + list_del_init(&bo_va->base.vm_status); ++ spin_unlock(&vm->moved_lock); + + /* If the BO is not in its preferred location add it back to + * the evicted list so that it gets validated again on the +@@ -1629,7 +1608,6 @@ int amdgpu_vm_bo_update(struct amdgpu_device *adev, + !(bo->preferred_domains & + amdgpu_mem_type_to_domain(bo->tbo.mem.mem_type))) + list_add_tail(&bo_va->base.vm_status, &vm->evicted); +- spin_unlock(&vm->status_lock); + + list_splice_init(&bo_va->invalids, &bo_va->valids); + bo_va->cleared = clear; +@@ -1841,14 +1819,14 @@ int amdgpu_vm_handle_moved(struct amdgpu_device *adev, + bool clear; + int r = 0; + +- spin_lock(&vm->status_lock); ++ spin_lock(&vm->moved_lock); + while (!list_empty(&vm->moved)) { + struct amdgpu_bo_va *bo_va; + struct reservation_object *resv; + + bo_va = list_first_entry(&vm->moved, + struct amdgpu_bo_va, base.vm_status); +- spin_unlock(&vm->status_lock); ++ spin_unlock(&vm->moved_lock); + + resv = bo_va->base.bo->tbo.resv; + +@@ -1869,9 +1847,9 @@ int amdgpu_vm_handle_moved(struct amdgpu_device *adev, + if (!clear && resv != vm->root.base.bo->tbo.resv) + reservation_object_unlock(resv); + +- spin_lock(&vm->status_lock); ++ spin_lock(&vm->moved_lock); + } +- spin_unlock(&vm->status_lock); ++ spin_unlock(&vm->moved_lock); + + return r; + } +@@ -1933,10 +1911,10 @@ static void amdgpu_vm_bo_insert_map(struct amdgpu_device *adev, + amdgpu_vm_prt_get(adev); + + if (bo && bo->tbo.resv == vm->root.base.bo->tbo.resv) { +- spin_lock(&vm->status_lock); ++ spin_lock(&vm->moved_lock); + if (list_empty(&bo_va->base.vm_status)) + list_add(&bo_va->base.vm_status, &vm->moved); +- spin_unlock(&vm->status_lock); ++ spin_unlock(&vm->moved_lock); + } + trace_amdgpu_vm_bo_map(bo_va, mapping); + } +@@ -2246,9 +2224,9 @@ void amdgpu_vm_bo_rmv(struct amdgpu_device *adev, + + list_del(&bo_va->base.bo_list); + +- spin_lock(&vm->status_lock); ++ spin_lock(&vm->moved_lock); + list_del(&bo_va->base.vm_status); +- spin_unlock(&vm->status_lock); ++ spin_unlock(&vm->moved_lock); + + list_for_each_entry_safe(mapping, next, &bo_va->valids, list) { + list_del(&mapping->list); +@@ -2291,30 +2269,26 @@ void amdgpu_vm_bo_invalidate(struct amdgpu_device *adev, + + bo_base->moved = true; + if (evicted && bo->tbo.resv == vm->root.base.bo->tbo.resv) { +- spin_lock(&bo_base->vm->status_lock); + if (bo->tbo.type == ttm_bo_type_kernel) + list_move(&bo_base->vm_status, &vm->evicted); + else + list_move_tail(&bo_base->vm_status, + &vm->evicted); +- spin_unlock(&bo_base->vm->status_lock); + continue; + } + + /* Don't add page tables to the moved state */ + if (bo->tbo.type == ttm_bo_type_kernel) { +- spin_lock(&bo_base->vm->status_lock); + if (list_empty(&bo_base->vm_status)) + list_add(&bo_base->vm_status, &vm->relocated); +- spin_unlock(&bo_base->vm->status_lock); + + continue; + } + +- spin_lock(&bo_base->vm->status_lock); ++ spin_lock(&bo_base->vm->moved_lock); + if (list_empty(&bo_base->vm_status)) + list_add(&bo_base->vm_status, &vm->moved); +- spin_unlock(&bo_base->vm->status_lock); ++ spin_unlock(&bo_base->vm->moved_lock); + } + } + +@@ -2440,9 +2414,9 @@ int amdgpu_vm_init(struct amdgpu_device *adev, struct amdgpu_vm *vm, + vm->va = RB_ROOT_CACHED; + for (i = 0; i < AMDGPU_MAX_VMHUBS; i++) + vm->reserved_vmid[i] = NULL; +- spin_lock_init(&vm->status_lock); + INIT_LIST_HEAD(&vm->evicted); + INIT_LIST_HEAD(&vm->relocated); ++ spin_lock_init(&vm->moved_lock); + INIT_LIST_HEAD(&vm->moved); + INIT_LIST_HEAD(&vm->freed); + +diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_vm.h b/drivers/gpu/drm/amd/amdgpu/amdgpu_vm.h +index 3492ab7..7a4c967 100644 +--- a/drivers/gpu/drm/amd/amdgpu/amdgpu_vm.h ++++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_vm.h +@@ -171,9 +171,6 @@ struct amdgpu_vm { + /* tree of virtual addresses mapped */ + struct rb_root_cached va; + +- /* protecting invalidated */ +- spinlock_t status_lock; +- + /* BOs who needs a validation */ + struct list_head evicted; + +@@ -182,6 +179,7 @@ struct amdgpu_vm { + + /* BOs moved, but not yet updated in the PT */ + struct list_head moved; ++ spinlock_t moved_lock; + + /* BO mappings freed, but not yet updated in the PT */ + struct list_head freed; +-- +2.7.4 + |