Lines Matching +full:gfx +full:- +full:mem
29 #include <linux/dma-fence-array.h>
32 #include <linux/dma-buf.h>
69 * Each GPUVM is represented by a 1-2 or 1-5 level page table, depending
90 #define START(node) ((node)->start)
91 #define LAST(node) ((node)->last)
100 * struct amdgpu_prt_cb - Helper to disable partial resident texture feature from a fence callback
116 * struct amdgpu_vm_tlb_seq_struct - Helper to increment the TLB flush sequence
131 * amdgpu_vm_set_pasid - manage pasid and vm ptr mapping
146 if (vm->pasid == pasid) in amdgpu_vm_set_pasid()
149 if (vm->pasid) { in amdgpu_vm_set_pasid()
150 r = xa_err(xa_erase_irq(&adev->vm_manager.pasids, vm->pasid)); in amdgpu_vm_set_pasid()
154 vm->pasid = 0; in amdgpu_vm_set_pasid()
158 r = xa_err(xa_store_irq(&adev->vm_manager.pasids, pasid, vm, in amdgpu_vm_set_pasid()
163 vm->pasid = pasid; in amdgpu_vm_set_pasid()
171 * amdgpu_vm_bo_evicted - vm_bo is evicted
180 struct amdgpu_vm *vm = vm_bo->vm; in amdgpu_vm_bo_evicted()
181 struct amdgpu_bo *bo = vm_bo->bo; in amdgpu_vm_bo_evicted()
183 vm_bo->moved = true; in amdgpu_vm_bo_evicted()
184 spin_lock(&vm_bo->vm->status_lock); in amdgpu_vm_bo_evicted()
185 if (bo->tbo.type == ttm_bo_type_kernel) in amdgpu_vm_bo_evicted()
186 list_move(&vm_bo->vm_status, &vm->evicted); in amdgpu_vm_bo_evicted()
188 list_move_tail(&vm_bo->vm_status, &vm->evicted); in amdgpu_vm_bo_evicted()
189 spin_unlock(&vm_bo->vm->status_lock); in amdgpu_vm_bo_evicted()
192 * amdgpu_vm_bo_moved - vm_bo is moved
201 spin_lock(&vm_bo->vm->status_lock); in amdgpu_vm_bo_moved()
202 list_move(&vm_bo->vm_status, &vm_bo->vm->moved); in amdgpu_vm_bo_moved()
203 spin_unlock(&vm_bo->vm->status_lock); in amdgpu_vm_bo_moved()
207 * amdgpu_vm_bo_idle - vm_bo is idle
216 spin_lock(&vm_bo->vm->status_lock); in amdgpu_vm_bo_idle()
217 list_move(&vm_bo->vm_status, &vm_bo->vm->idle); in amdgpu_vm_bo_idle()
218 spin_unlock(&vm_bo->vm->status_lock); in amdgpu_vm_bo_idle()
219 vm_bo->moved = false; in amdgpu_vm_bo_idle()
223 * amdgpu_vm_bo_invalidated - vm_bo is invalidated
232 spin_lock(&vm_bo->vm->status_lock); in amdgpu_vm_bo_invalidated()
233 list_move(&vm_bo->vm_status, &vm_bo->vm->invalidated); in amdgpu_vm_bo_invalidated()
234 spin_unlock(&vm_bo->vm->status_lock); in amdgpu_vm_bo_invalidated()
238 * amdgpu_vm_bo_evicted_user - vm_bo is evicted
247 vm_bo->moved = true; in amdgpu_vm_bo_evicted_user()
248 spin_lock(&vm_bo->vm->status_lock); in amdgpu_vm_bo_evicted_user()
249 list_move(&vm_bo->vm_status, &vm_bo->vm->evicted_user); in amdgpu_vm_bo_evicted_user()
250 spin_unlock(&vm_bo->vm->status_lock); in amdgpu_vm_bo_evicted_user()
254 * amdgpu_vm_bo_relocated - vm_bo is reloacted
263 if (vm_bo->bo->parent) { in amdgpu_vm_bo_relocated()
264 spin_lock(&vm_bo->vm->status_lock); in amdgpu_vm_bo_relocated()
265 list_move(&vm_bo->vm_status, &vm_bo->vm->relocated); in amdgpu_vm_bo_relocated()
266 spin_unlock(&vm_bo->vm->status_lock); in amdgpu_vm_bo_relocated()
273 * amdgpu_vm_bo_done - vm_bo is done
282 spin_lock(&vm_bo->vm->status_lock); in amdgpu_vm_bo_done()
283 list_move(&vm_bo->vm_status, &vm_bo->vm->done); in amdgpu_vm_bo_done()
284 spin_unlock(&vm_bo->vm->status_lock); in amdgpu_vm_bo_done()
288 * amdgpu_vm_bo_reset_state_machine - reset the vm_bo state machine
298 spin_lock(&vm->status_lock); in amdgpu_vm_bo_reset_state_machine()
299 list_splice_init(&vm->done, &vm->invalidated); in amdgpu_vm_bo_reset_state_machine()
300 list_for_each_entry(vm_bo, &vm->invalidated, vm_status) in amdgpu_vm_bo_reset_state_machine()
301 vm_bo->moved = true; in amdgpu_vm_bo_reset_state_machine()
302 list_for_each_entry_safe(vm_bo, tmp, &vm->idle, vm_status) { in amdgpu_vm_bo_reset_state_machine()
303 struct amdgpu_bo *bo = vm_bo->bo; in amdgpu_vm_bo_reset_state_machine()
305 vm_bo->moved = true; in amdgpu_vm_bo_reset_state_machine()
306 if (!bo || bo->tbo.type != ttm_bo_type_kernel) in amdgpu_vm_bo_reset_state_machine()
307 list_move(&vm_bo->vm_status, &vm_bo->vm->moved); in amdgpu_vm_bo_reset_state_machine()
308 else if (bo->parent) in amdgpu_vm_bo_reset_state_machine()
309 list_move(&vm_bo->vm_status, &vm_bo->vm->relocated); in amdgpu_vm_bo_reset_state_machine()
311 spin_unlock(&vm->status_lock); in amdgpu_vm_bo_reset_state_machine()
315 * amdgpu_vm_update_shared - helper to update shared memory stat
324 struct amdgpu_vm *vm = base->vm; in amdgpu_vm_update_shared()
325 struct amdgpu_bo *bo = base->bo; in amdgpu_vm_update_shared()
330 spin_lock(&vm->status_lock); in amdgpu_vm_update_shared()
331 shared = drm_gem_object_is_shared_for_memory_stats(&bo->tbo.base); in amdgpu_vm_update_shared()
332 if (base->shared != shared) { in amdgpu_vm_update_shared()
333 base->shared = shared; in amdgpu_vm_update_shared()
335 vm->stats[bo_memtype].drm.shared += size; in amdgpu_vm_update_shared()
336 vm->stats[bo_memtype].drm.private -= size; in amdgpu_vm_update_shared()
338 vm->stats[bo_memtype].drm.shared -= size; in amdgpu_vm_update_shared()
339 vm->stats[bo_memtype].drm.private += size; in amdgpu_vm_update_shared()
342 spin_unlock(&vm->status_lock); in amdgpu_vm_update_shared()
346 * amdgpu_vm_bo_update_shared - callback when bo gets shared/unshared
356 for (base = bo->vm_bo; base; base = base->next) in amdgpu_vm_bo_update_shared()
361 * amdgpu_vm_update_stats_locked - helper to update normal memory stat
364 * be bo->tbo.resource
365 * @sign: if we should add (+1) or subtract (-1) from the stat
373 struct amdgpu_vm *vm = base->vm; in amdgpu_vm_update_stats_locked()
374 struct amdgpu_bo *bo = base->bo; in amdgpu_vm_update_stats_locked()
378 /* For drm-total- and drm-shared-, BO are accounted by their preferred in amdgpu_vm_update_stats_locked()
381 if (base->shared) in amdgpu_vm_update_stats_locked()
382 vm->stats[bo_memtype].drm.shared += size; in amdgpu_vm_update_stats_locked()
384 vm->stats[bo_memtype].drm.private += size; in amdgpu_vm_update_stats_locked()
386 if (res && res->mem_type < __AMDGPU_PL_NUM) { in amdgpu_vm_update_stats_locked()
387 uint32_t res_memtype = res->mem_type; in amdgpu_vm_update_stats_locked()
389 vm->stats[res_memtype].drm.resident += size; in amdgpu_vm_update_stats_locked()
393 if (bo->flags & AMDGPU_GEM_CREATE_DISCARDABLE) in amdgpu_vm_update_stats_locked()
394 vm->stats[res_memtype].drm.purgeable += size; in amdgpu_vm_update_stats_locked()
395 if (!(bo->preferred_domains & amdgpu_mem_type_to_domain(res_memtype))) in amdgpu_vm_update_stats_locked()
396 vm->stats[bo_memtype].evicted += size; in amdgpu_vm_update_stats_locked()
401 * amdgpu_vm_update_stats - helper to update normal memory stat
404 * be bo->tbo.resource
405 * @sign: if we should add (+1) or subtract (-1) from the stat
412 struct amdgpu_vm *vm = base->vm; in amdgpu_vm_update_stats()
414 spin_lock(&vm->status_lock); in amdgpu_vm_update_stats()
416 spin_unlock(&vm->status_lock); in amdgpu_vm_update_stats()
420 * amdgpu_vm_bo_base_init - Adds bo to the list of bos associated with the vm
432 base->vm = vm; in amdgpu_vm_bo_base_init()
433 base->bo = bo; in amdgpu_vm_bo_base_init()
434 base->next = NULL; in amdgpu_vm_bo_base_init()
435 INIT_LIST_HEAD(&base->vm_status); in amdgpu_vm_bo_base_init()
439 base->next = bo->vm_bo; in amdgpu_vm_bo_base_init()
440 bo->vm_bo = base; in amdgpu_vm_bo_base_init()
442 spin_lock(&vm->status_lock); in amdgpu_vm_bo_base_init()
443 base->shared = drm_gem_object_is_shared_for_memory_stats(&bo->tbo.base); in amdgpu_vm_bo_base_init()
444 amdgpu_vm_update_stats_locked(base, bo->tbo.resource, +1); in amdgpu_vm_bo_base_init()
445 spin_unlock(&vm->status_lock); in amdgpu_vm_bo_base_init()
450 dma_resv_assert_held(vm->root.bo->tbo.base.resv); in amdgpu_vm_bo_base_init()
452 ttm_bo_set_bulk_move(&bo->tbo, &vm->lru_bulk_move); in amdgpu_vm_bo_base_init()
453 if (bo->tbo.type == ttm_bo_type_kernel && bo->parent) in amdgpu_vm_bo_base_init()
458 if (bo->preferred_domains & in amdgpu_vm_bo_base_init()
459 amdgpu_mem_type_to_domain(bo->tbo.resource->mem_type)) in amdgpu_vm_bo_base_init()
471 * amdgpu_vm_lock_pd - lock PD in drm_exec
483 return drm_exec_prepare_obj(exec, &vm->root.bo->tbo.base, in amdgpu_vm_lock_pd()
488 * amdgpu_vm_move_to_lru_tail - move all BOs to the end of LRU
499 spin_lock(&adev->mman.bdev.lru_lock); in amdgpu_vm_move_to_lru_tail()
500 ttm_lru_bulk_move_tail(&vm->lru_bulk_move); in amdgpu_vm_move_to_lru_tail()
501 spin_unlock(&adev->mman.bdev.lru_lock); in amdgpu_vm_move_to_lru_tail()
510 r = drm_sched_entity_init(&vm->immediate, DRM_SCHED_PRIORITY_NORMAL, in amdgpu_vm_init_entities()
511 adev->vm_manager.vm_pte_scheds, in amdgpu_vm_init_entities()
512 adev->vm_manager.vm_pte_num_scheds, NULL); in amdgpu_vm_init_entities()
516 return drm_sched_entity_init(&vm->delayed, DRM_SCHED_PRIORITY_NORMAL, in amdgpu_vm_init_entities()
517 adev->vm_manager.vm_pte_scheds, in amdgpu_vm_init_entities()
518 adev->vm_manager.vm_pte_num_scheds, NULL); in amdgpu_vm_init_entities()
521 drm_sched_entity_destroy(&vm->immediate); in amdgpu_vm_init_entities()
528 drm_sched_entity_destroy(&vm->immediate); in amdgpu_vm_fini_entities()
529 drm_sched_entity_destroy(&vm->delayed); in amdgpu_vm_fini_entities()
533 * amdgpu_vm_generation - return the page table re-generation counter
537 * Returns a page table re-generation token to allow checking if submissions
543 uint64_t result = (u64)atomic_read(&adev->vram_lost_counter) << 32; in amdgpu_vm_generation()
548 result += lower_32_bits(vm->generation); in amdgpu_vm_generation()
549 /* Add one if the page tables will be re-generated on next CS */ in amdgpu_vm_generation()
550 if (drm_sched_entity_error(&vm->delayed)) in amdgpu_vm_generation()
557 * amdgpu_vm_validate - validate evicted BOs tracked in the VM
565 * Validate the page table BOs and per-VM BOs on command submission if
582 if (vm->generation != new_vm_generation) { in amdgpu_vm_validate()
583 vm->generation = new_vm_generation; in amdgpu_vm_validate()
591 spin_lock(&vm->status_lock); in amdgpu_vm_validate()
592 while (!list_empty(&vm->evicted)) { in amdgpu_vm_validate()
593 bo_base = list_first_entry(&vm->evicted, in amdgpu_vm_validate()
596 spin_unlock(&vm->status_lock); in amdgpu_vm_validate()
598 bo = bo_base->bo; in amdgpu_vm_validate()
604 if (bo->tbo.type != ttm_bo_type_kernel) { in amdgpu_vm_validate()
607 vm->update_funcs->map_table(to_amdgpu_bo_vm(bo)); in amdgpu_vm_validate()
610 spin_lock(&vm->status_lock); in amdgpu_vm_validate()
612 while (ticket && !list_empty(&vm->evicted_user)) { in amdgpu_vm_validate()
613 bo_base = list_first_entry(&vm->evicted_user, in amdgpu_vm_validate()
616 spin_unlock(&vm->status_lock); in amdgpu_vm_validate()
618 bo = bo_base->bo; in amdgpu_vm_validate()
620 if (dma_resv_locking_ctx(bo->tbo.base.resv) != ticket) { in amdgpu_vm_validate()
625 pr_warn_ratelimited("pid %d\n", ti->pid); in amdgpu_vm_validate()
629 return -EINVAL; in amdgpu_vm_validate()
638 spin_lock(&vm->status_lock); in amdgpu_vm_validate()
640 spin_unlock(&vm->status_lock); in amdgpu_vm_validate()
643 vm->evicting = false; in amdgpu_vm_validate()
650 * amdgpu_vm_ready - check VM is ready for updates
665 ret = !vm->evicting; in amdgpu_vm_ready()
668 spin_lock(&vm->status_lock); in amdgpu_vm_ready()
669 empty = list_empty(&vm->evicted); in amdgpu_vm_ready()
670 spin_unlock(&vm->status_lock); in amdgpu_vm_ready()
676 * amdgpu_vm_check_compute_bug - check whether asic has compute vm bug
691 /* Compute has a VM bug for GFX version < 7. in amdgpu_vm_check_compute_bug()
692 Compute has a VM bug for GFX 8 MEC firmware version < 673.*/ in amdgpu_vm_check_compute_bug()
693 if (ip_block->version->major <= 7) in amdgpu_vm_check_compute_bug()
695 else if (ip_block->version->major == 8) in amdgpu_vm_check_compute_bug()
696 if (adev->gfx.mec_fw_version < 673) in amdgpu_vm_check_compute_bug()
700 for (i = 0; i < adev->num_rings; i++) { in amdgpu_vm_check_compute_bug()
701 ring = adev->rings[i]; in amdgpu_vm_check_compute_bug()
702 if (ring->funcs->type == AMDGPU_RING_TYPE_COMPUTE) in amdgpu_vm_check_compute_bug()
704 ring->has_compute_vm_bug = has_compute_vm_bug; in amdgpu_vm_check_compute_bug()
706 ring->has_compute_vm_bug = false; in amdgpu_vm_check_compute_bug()
711 * amdgpu_vm_need_pipeline_sync - Check if pipe sync is needed for job.
722 struct amdgpu_device *adev = ring->adev; in amdgpu_vm_need_pipeline_sync()
723 unsigned vmhub = ring->vm_hub; in amdgpu_vm_need_pipeline_sync()
724 struct amdgpu_vmid_mgr *id_mgr = &adev->vm_manager.id_mgr[vmhub]; in amdgpu_vm_need_pipeline_sync()
726 if (job->vmid == 0) in amdgpu_vm_need_pipeline_sync()
729 if (job->vm_needs_flush || ring->has_compute_vm_bug) in amdgpu_vm_need_pipeline_sync()
732 if (ring->funcs->emit_gds_switch && job->gds_switch_needed) in amdgpu_vm_need_pipeline_sync()
735 if (amdgpu_vmid_had_gpu_reset(adev, &id_mgr->ids[job->vmid])) in amdgpu_vm_need_pipeline_sync()
742 * amdgpu_vm_flush - hardware flush the vm
756 struct amdgpu_device *adev = ring->adev; in amdgpu_vm_flush()
757 unsigned vmhub = ring->vm_hub; in amdgpu_vm_flush()
758 struct amdgpu_vmid_mgr *id_mgr = &adev->vm_manager.id_mgr[vmhub]; in amdgpu_vm_flush()
759 struct amdgpu_vmid *id = &id_mgr->ids[job->vmid]; in amdgpu_vm_flush()
760 bool spm_update_needed = job->spm_update_needed; in amdgpu_vm_flush()
761 bool gds_switch_needed = ring->funcs->emit_gds_switch && in amdgpu_vm_flush()
762 job->gds_switch_needed; in amdgpu_vm_flush()
763 bool vm_flush_needed = job->vm_needs_flush; in amdgpu_vm_flush()
776 mutex_lock(&id_mgr->lock); in amdgpu_vm_flush()
777 if (id->pasid != job->pasid || !id->pasid_mapping || in amdgpu_vm_flush()
778 !dma_fence_is_signaled(id->pasid_mapping)) in amdgpu_vm_flush()
780 mutex_unlock(&id_mgr->lock); in amdgpu_vm_flush()
782 gds_switch_needed &= !!ring->funcs->emit_gds_switch; in amdgpu_vm_flush()
783 vm_flush_needed &= !!ring->funcs->emit_vm_flush && in amdgpu_vm_flush()
784 job->vm_pd_addr != AMDGPU_BO_INVALID_OFFSET; in amdgpu_vm_flush()
785 pasid_mapping_needed &= adev->gmc.gmc_funcs->emit_pasid_mapping && in amdgpu_vm_flush()
786 ring->funcs->emit_wreg; in amdgpu_vm_flush()
789 !(job->enforce_isolation && !job->vmid)) in amdgpu_vm_flush()
793 if (ring->funcs->init_cond_exec) in amdgpu_vm_flush()
795 ring->cond_exe_gpu_addr); in amdgpu_vm_flush()
800 if (adev->gfx.enable_cleaner_shader && in amdgpu_vm_flush()
801 ring->funcs->emit_cleaner_shader && in amdgpu_vm_flush()
802 job->enforce_isolation) in amdgpu_vm_flush()
803 ring->funcs->emit_cleaner_shader(ring); in amdgpu_vm_flush()
806 trace_amdgpu_vm_flush(ring, job->vmid, job->vm_pd_addr); in amdgpu_vm_flush()
807 amdgpu_ring_emit_vm_flush(ring, job->vmid, job->vm_pd_addr); in amdgpu_vm_flush()
811 amdgpu_gmc_emit_pasid_mapping(ring, job->vmid, job->pasid); in amdgpu_vm_flush()
813 if (spm_update_needed && adev->gfx.rlc.funcs->update_spm_vmid) in amdgpu_vm_flush()
814 adev->gfx.rlc.funcs->update_spm_vmid(adev, ring, job->vmid); in amdgpu_vm_flush()
816 if (!ring->is_mes_queue && ring->funcs->emit_gds_switch && in amdgpu_vm_flush()
818 amdgpu_ring_emit_gds_switch(ring, job->vmid, job->gds_base, in amdgpu_vm_flush()
819 job->gds_size, job->gws_base, in amdgpu_vm_flush()
820 job->gws_size, job->oa_base, in amdgpu_vm_flush()
821 job->oa_size); in amdgpu_vm_flush()
831 mutex_lock(&id_mgr->lock); in amdgpu_vm_flush()
832 dma_fence_put(id->last_flush); in amdgpu_vm_flush()
833 id->last_flush = dma_fence_get(fence); in amdgpu_vm_flush()
834 id->current_gpu_reset_count = in amdgpu_vm_flush()
835 atomic_read(&adev->gpu_reset_counter); in amdgpu_vm_flush()
836 mutex_unlock(&id_mgr->lock); in amdgpu_vm_flush()
840 mutex_lock(&id_mgr->lock); in amdgpu_vm_flush()
841 id->pasid = job->pasid; in amdgpu_vm_flush()
842 dma_fence_put(id->pasid_mapping); in amdgpu_vm_flush()
843 id->pasid_mapping = dma_fence_get(fence); in amdgpu_vm_flush()
844 mutex_unlock(&id_mgr->lock); in amdgpu_vm_flush()
851 if (ring->funcs->emit_switch_buffer) { in amdgpu_vm_flush()
861 * amdgpu_vm_bo_find - find the bo_va for a specific vm & bo
880 for (base = bo->vm_bo; base; base = base->next) { in amdgpu_vm_bo_find()
881 if (base->vm != vm) in amdgpu_vm_bo_find()
890 * amdgpu_vm_map_gart - Resolve gart mapping of addr
917 * amdgpu_vm_update_pdes - make sure that all directories are valid
937 spin_lock(&vm->status_lock); in amdgpu_vm_update_pdes()
938 list_splice_init(&vm->relocated, &relocated); in amdgpu_vm_update_pdes()
939 spin_unlock(&vm->status_lock); in amdgpu_vm_update_pdes()
945 return -ENODEV; in amdgpu_vm_update_pdes()
952 r = vm->update_funcs->prepare(¶ms, NULL); in amdgpu_vm_update_pdes()
958 flush_tlb_needed |= entry->moved; in amdgpu_vm_update_pdes()
965 r = vm->update_funcs->commit(¶ms, &vm->last_update); in amdgpu_vm_update_pdes()
970 atomic64_inc(&vm->tlb_seq); in amdgpu_vm_update_pdes()
984 * amdgpu_vm_tlb_seq_cb - make sure to increment tlb sequence
996 atomic64_inc(&tlb_cb->vm->tlb_seq); in amdgpu_vm_tlb_seq_cb()
1001 * amdgpu_vm_tlb_flush - prepare TLB flush
1014 struct amdgpu_vm *vm = params->vm; in amdgpu_vm_tlb_flush()
1016 tlb_cb->vm = vm; in amdgpu_vm_tlb_flush()
1018 amdgpu_vm_tlb_seq_cb(NULL, &tlb_cb->cb); in amdgpu_vm_tlb_flush()
1022 if (!dma_fence_add_callback(*fence, &tlb_cb->cb, in amdgpu_vm_tlb_flush()
1024 dma_fence_put(vm->last_tlb_flush); in amdgpu_vm_tlb_flush()
1025 vm->last_tlb_flush = dma_fence_get(*fence); in amdgpu_vm_tlb_flush()
1027 amdgpu_vm_tlb_seq_cb(NULL, &tlb_cb->cb); in amdgpu_vm_tlb_flush()
1031 if (!params->unlocked && vm->is_compute_context) { in amdgpu_vm_tlb_flush()
1032 amdgpu_vm_tlb_fence_create(params->adev, vm, fence); in amdgpu_vm_tlb_flush()
1035 dma_resv_add_fence(vm->root.bo->tbo.base.resv, *fence, in amdgpu_vm_tlb_flush()
1041 * amdgpu_vm_update_range - update a range in the vm page table
1078 return -ENODEV; in amdgpu_vm_update_range()
1083 return -ENOMEM; in amdgpu_vm_update_range()
1087 * heavy-weight flush TLB unconditionally. in amdgpu_vm_update_range()
1089 flush_tlb |= adev->gmc.xgmi.num_physical_nodes && in amdgpu_vm_update_range()
1108 if (vm->evicting) { in amdgpu_vm_update_range()
1109 r = -EBUSY; in amdgpu_vm_update_range()
1113 if (!unlocked && !dma_fence_is_signaled(vm->last_unlocked)) { in amdgpu_vm_update_range()
1116 amdgpu_bo_fence(vm->root.bo, vm->last_unlocked, true); in amdgpu_vm_update_range()
1117 swap(vm->last_unlocked, tmp); in amdgpu_vm_update_range()
1121 r = vm->update_funcs->prepare(¶ms, sync); in amdgpu_vm_update_range()
1126 (last - start + 1) * AMDGPU_GPU_PAGE_SIZE, &cursor); in amdgpu_vm_update_range()
1147 pages_addr[idx - 1] + PAGE_SIZE)) in amdgpu_vm_update_range()
1151 count--; in amdgpu_vm_update_range()
1179 r = vm->update_funcs->commit(¶ms, fence); in amdgpu_vm_update_range()
1200 spin_lock(&vm->status_lock); in amdgpu_vm_get_memory()
1201 memcpy(stats, vm->stats, sizeof(*stats) * __AMDGPU_PL_NUM); in amdgpu_vm_get_memory()
1202 spin_unlock(&vm->status_lock); in amdgpu_vm_get_memory()
1206 * amdgpu_vm_bo_update - update all BO mappings in the vm page table
1215 * 0 for success, -EINVAL for failure.
1220 struct amdgpu_bo *bo = bo_va->base.bo; in amdgpu_vm_bo_update()
1221 struct amdgpu_vm *vm = bo_va->base.vm; in amdgpu_vm_bo_update()
1225 struct ttm_resource *mem; in amdgpu_vm_bo_update() local
1235 mem = NULL; in amdgpu_vm_bo_update()
1240 r = amdgpu_sync_resv(adev, &sync, vm->root.bo->tbo.base.resv, in amdgpu_vm_bo_update()
1245 r = amdgpu_sync_kfd(&sync, bo->tbo.base.resv); in amdgpu_vm_bo_update()
1250 mem = NULL; in amdgpu_vm_bo_update()
1255 struct drm_gem_object *obj = &bo->tbo.base; in amdgpu_vm_bo_update()
1257 if (obj->import_attach && bo_va->is_xgmi) { in amdgpu_vm_bo_update()
1258 struct dma_buf *dma_buf = obj->import_attach->dmabuf; in amdgpu_vm_bo_update()
1259 struct drm_gem_object *gobj = dma_buf->priv; in amdgpu_vm_bo_update()
1262 if (abo->tbo.resource && in amdgpu_vm_bo_update()
1263 abo->tbo.resource->mem_type == TTM_PL_VRAM) in amdgpu_vm_bo_update()
1266 mem = bo->tbo.resource; in amdgpu_vm_bo_update()
1267 if (mem && (mem->mem_type == TTM_PL_TT || in amdgpu_vm_bo_update()
1268 mem->mem_type == AMDGPU_PL_PREEMPT)) in amdgpu_vm_bo_update()
1269 pages_addr = bo->tbo.ttm->dma_address; in amdgpu_vm_bo_update()
1272 r = amdgpu_sync_resv(adev, &sync, bo->tbo.base.resv, in amdgpu_vm_bo_update()
1281 flags = amdgpu_ttm_tt_pte_flags(adev, bo->tbo.ttm, mem); in amdgpu_vm_bo_update()
1286 bo_adev = amdgpu_ttm_adev(bo->tbo.bdev); in amdgpu_vm_bo_update()
1287 vram_base = bo_adev->vm_manager.vram_base_offset; in amdgpu_vm_bo_update()
1288 uncached = (bo->flags & AMDGPU_GEM_CREATE_UNCACHED) != 0; in amdgpu_vm_bo_update()
1296 last_update = &vm->last_update; in amdgpu_vm_bo_update()
1298 last_update = &bo_va->last_pt_update; in amdgpu_vm_bo_update()
1300 if (!clear && bo_va->base.moved) { in amdgpu_vm_bo_update()
1302 list_splice_init(&bo_va->valids, &bo_va->invalids); in amdgpu_vm_bo_update()
1304 } else if (bo_va->cleared != clear) { in amdgpu_vm_bo_update()
1305 list_splice_init(&bo_va->valids, &bo_va->invalids); in amdgpu_vm_bo_update()
1308 list_for_each_entry(mapping, &bo_va->invalids, list) { in amdgpu_vm_bo_update()
1311 /* normally,bo_va->flags only contians READABLE and WIRTEABLE bit go here in amdgpu_vm_bo_update()
1314 if (!(mapping->flags & AMDGPU_PTE_READABLE)) in amdgpu_vm_bo_update()
1316 if (!(mapping->flags & AMDGPU_PTE_WRITEABLE)) in amdgpu_vm_bo_update()
1325 !uncached, &sync, mapping->start, in amdgpu_vm_bo_update()
1326 mapping->last, update_flags, in amdgpu_vm_bo_update()
1327 mapping->offset, vram_base, mem, in amdgpu_vm_bo_update()
1338 if (bo->tbo.resource && in amdgpu_vm_bo_update()
1339 !(bo->preferred_domains & in amdgpu_vm_bo_update()
1340 amdgpu_mem_type_to_domain(bo->tbo.resource->mem_type))) in amdgpu_vm_bo_update()
1341 amdgpu_vm_bo_evicted(&bo_va->base); in amdgpu_vm_bo_update()
1343 amdgpu_vm_bo_idle(&bo_va->base); in amdgpu_vm_bo_update()
1345 amdgpu_vm_bo_done(&bo_va->base); in amdgpu_vm_bo_update()
1348 list_splice_init(&bo_va->invalids, &bo_va->valids); in amdgpu_vm_bo_update()
1349 bo_va->cleared = clear; in amdgpu_vm_bo_update()
1350 bo_va->base.moved = false; in amdgpu_vm_bo_update()
1353 list_for_each_entry(mapping, &bo_va->valids, list) in amdgpu_vm_bo_update()
1363 * amdgpu_vm_update_prt_state - update the global PRT state
1372 spin_lock_irqsave(&adev->vm_manager.prt_lock, flags); in amdgpu_vm_update_prt_state()
1373 enable = !!atomic_read(&adev->vm_manager.num_prt_users); in amdgpu_vm_update_prt_state()
1374 adev->gmc.gmc_funcs->set_prt(adev, enable); in amdgpu_vm_update_prt_state()
1375 spin_unlock_irqrestore(&adev->vm_manager.prt_lock, flags); in amdgpu_vm_update_prt_state()
1379 * amdgpu_vm_prt_get - add a PRT user
1385 if (!adev->gmc.gmc_funcs->set_prt) in amdgpu_vm_prt_get()
1388 if (atomic_inc_return(&adev->vm_manager.num_prt_users) == 1) in amdgpu_vm_prt_get()
1393 * amdgpu_vm_prt_put - drop a PRT user
1399 if (atomic_dec_return(&adev->vm_manager.num_prt_users) == 0) in amdgpu_vm_prt_put()
1404 * amdgpu_vm_prt_cb - callback for updating the PRT status
1413 amdgpu_vm_prt_put(cb->adev); in amdgpu_vm_prt_cb()
1418 * amdgpu_vm_add_prt_cb - add callback for updating the PRT status
1428 if (!adev->gmc.gmc_funcs->set_prt) in amdgpu_vm_add_prt_cb()
1439 cb->adev = adev; in amdgpu_vm_add_prt_cb()
1440 if (!fence || dma_fence_add_callback(fence, &cb->cb, in amdgpu_vm_add_prt_cb()
1442 amdgpu_vm_prt_cb(fence, &cb->cb); in amdgpu_vm_add_prt_cb()
1447 * amdgpu_vm_free_mapping - free a mapping
1461 if (mapping->flags & AMDGPU_PTE_PRT_FLAG(adev)) in amdgpu_vm_free_mapping()
1467 * amdgpu_vm_prt_fini - finish all prt mappings
1476 struct dma_resv *resv = vm->root.bo->tbo.base.resv; in amdgpu_vm_prt_fini()
1488 * amdgpu_vm_clear_freed - clear freed BOs in the PT
1517 r = amdgpu_sync_resv(adev, &sync, vm->root.bo->tbo.base.resv, in amdgpu_vm_clear_freed()
1522 while (!list_empty(&vm->freed)) { in amdgpu_vm_clear_freed()
1523 mapping = list_first_entry(&vm->freed, in amdgpu_vm_clear_freed()
1525 list_del(&mapping->list); in amdgpu_vm_clear_freed()
1528 &sync, mapping->start, mapping->last, in amdgpu_vm_clear_freed()
1551 * amdgpu_vm_handle_moved - handle moved BOs in the PT
1573 spin_lock(&vm->status_lock); in amdgpu_vm_handle_moved()
1574 while (!list_empty(&vm->moved)) { in amdgpu_vm_handle_moved()
1575 bo_va = list_first_entry(&vm->moved, struct amdgpu_bo_va, in amdgpu_vm_handle_moved()
1577 spin_unlock(&vm->status_lock); in amdgpu_vm_handle_moved()
1583 spin_lock(&vm->status_lock); in amdgpu_vm_handle_moved()
1586 while (!list_empty(&vm->invalidated)) { in amdgpu_vm_handle_moved()
1587 bo_va = list_first_entry(&vm->invalidated, struct amdgpu_bo_va, in amdgpu_vm_handle_moved()
1589 resv = bo_va->base.bo->tbo.base.resv; in amdgpu_vm_handle_moved()
1590 spin_unlock(&vm->status_lock); in amdgpu_vm_handle_moved()
1593 if (!adev->debug_vm && dma_resv_trylock(resv)) { in amdgpu_vm_handle_moved()
1616 if (vm->is_compute_context && in amdgpu_vm_handle_moved()
1617 bo_va->base.bo->tbo.base.import_attach && in amdgpu_vm_handle_moved()
1618 (!bo_va->base.bo->tbo.resource || in amdgpu_vm_handle_moved()
1619 bo_va->base.bo->tbo.resource->mem_type == TTM_PL_SYSTEM)) in amdgpu_vm_handle_moved()
1620 amdgpu_vm_bo_evicted_user(&bo_va->base); in amdgpu_vm_handle_moved()
1622 spin_lock(&vm->status_lock); in amdgpu_vm_handle_moved()
1624 spin_unlock(&vm->status_lock); in amdgpu_vm_handle_moved()
1630 * amdgpu_vm_flush_compute_tlb - Flush TLB on compute VM
1651 WARN_ON_ONCE(!vm->is_compute_context); in amdgpu_vm_flush_compute_tlb()
1658 if (atomic64_xchg(&vm->kfd_last_flushed_seq, tlb_seq) == tlb_seq) in amdgpu_vm_flush_compute_tlb()
1661 if (adev->family == AMDGPU_FAMILY_AI || in amdgpu_vm_flush_compute_tlb()
1662 adev->family == AMDGPU_FAMILY_RV) in amdgpu_vm_flush_compute_tlb()
1666 r = amdgpu_gmc_flush_gpu_tlb_pasid(adev, vm->pasid, flush_type, in amdgpu_vm_flush_compute_tlb()
1675 * amdgpu_vm_bo_add - add a bo to a specific vm
1699 amdgpu_vm_bo_base_init(&bo_va->base, vm, bo); in amdgpu_vm_bo_add()
1701 bo_va->ref_count = 1; in amdgpu_vm_bo_add()
1702 bo_va->last_pt_update = dma_fence_get_stub(); in amdgpu_vm_bo_add()
1703 INIT_LIST_HEAD(&bo_va->valids); in amdgpu_vm_bo_add()
1704 INIT_LIST_HEAD(&bo_va->invalids); in amdgpu_vm_bo_add()
1709 dma_resv_assert_held(bo->tbo.base.resv); in amdgpu_vm_bo_add()
1711 bo_va->is_xgmi = true; in amdgpu_vm_bo_add()
1721 * amdgpu_vm_bo_insert_map - insert a new mapping
1733 struct amdgpu_vm *vm = bo_va->base.vm; in amdgpu_vm_bo_insert_map()
1734 struct amdgpu_bo *bo = bo_va->base.bo; in amdgpu_vm_bo_insert_map()
1736 mapping->bo_va = bo_va; in amdgpu_vm_bo_insert_map()
1737 list_add(&mapping->list, &bo_va->invalids); in amdgpu_vm_bo_insert_map()
1738 amdgpu_vm_it_insert(mapping, &vm->va); in amdgpu_vm_bo_insert_map()
1740 if (mapping->flags & AMDGPU_PTE_PRT_FLAG(adev)) in amdgpu_vm_bo_insert_map()
1743 if (amdgpu_vm_is_bo_always_valid(vm, bo) && !bo_va->base.moved) in amdgpu_vm_bo_insert_map()
1744 amdgpu_vm_bo_moved(&bo_va->base); in amdgpu_vm_bo_insert_map()
1761 return -EINVAL; in amdgpu_vm_verify_parameters()
1766 return -EINVAL; in amdgpu_vm_verify_parameters()
1770 return -EINVAL; in amdgpu_vm_verify_parameters()
1773 lpfn = (saddr + size - 1) >> AMDGPU_GPU_PAGE_SHIFT; in amdgpu_vm_verify_parameters()
1774 if (lpfn >= adev->vm_manager.max_pfn) in amdgpu_vm_verify_parameters()
1775 return -EINVAL; in amdgpu_vm_verify_parameters()
1781 * amdgpu_vm_bo_map - map bo inside a vm
1803 struct amdgpu_bo *bo = bo_va->base.bo; in amdgpu_vm_bo_map()
1804 struct amdgpu_vm *vm = bo_va->base.vm; in amdgpu_vm_bo_map()
1813 eaddr = saddr + (size - 1) / AMDGPU_GPU_PAGE_SIZE; in amdgpu_vm_bo_map()
1815 tmp = amdgpu_vm_it_iter_first(&vm->va, saddr, eaddr); in amdgpu_vm_bo_map()
1818 dev_err(adev->dev, "bo %p va 0x%010Lx-0x%010Lx conflict with " in amdgpu_vm_bo_map()
1819 "0x%010Lx-0x%010Lx\n", bo, saddr, eaddr, in amdgpu_vm_bo_map()
1820 tmp->start, tmp->last + 1); in amdgpu_vm_bo_map()
1821 return -EINVAL; in amdgpu_vm_bo_map()
1826 return -ENOMEM; in amdgpu_vm_bo_map()
1828 mapping->start = saddr; in amdgpu_vm_bo_map()
1829 mapping->last = eaddr; in amdgpu_vm_bo_map()
1830 mapping->offset = offset; in amdgpu_vm_bo_map()
1831 mapping->flags = flags; in amdgpu_vm_bo_map()
1839 * amdgpu_vm_bo_replace_map - map bo inside a vm, replacing existing mappings
1862 struct amdgpu_bo *bo = bo_va->base.bo; in amdgpu_vm_bo_replace_map()
1873 return -ENOMEM; in amdgpu_vm_bo_replace_map()
1875 r = amdgpu_vm_bo_clear_mappings(adev, bo_va->base.vm, saddr, size); in amdgpu_vm_bo_replace_map()
1882 eaddr = saddr + (size - 1) / AMDGPU_GPU_PAGE_SIZE; in amdgpu_vm_bo_replace_map()
1884 mapping->start = saddr; in amdgpu_vm_bo_replace_map()
1885 mapping->last = eaddr; in amdgpu_vm_bo_replace_map()
1886 mapping->offset = offset; in amdgpu_vm_bo_replace_map()
1887 mapping->flags = flags; in amdgpu_vm_bo_replace_map()
1895 * amdgpu_vm_bo_unmap - remove bo mapping from vm
1913 struct amdgpu_vm *vm = bo_va->base.vm; in amdgpu_vm_bo_unmap()
1918 list_for_each_entry(mapping, &bo_va->valids, list) { in amdgpu_vm_bo_unmap()
1919 if (mapping->start == saddr) in amdgpu_vm_bo_unmap()
1923 if (&mapping->list == &bo_va->valids) { in amdgpu_vm_bo_unmap()
1926 list_for_each_entry(mapping, &bo_va->invalids, list) { in amdgpu_vm_bo_unmap()
1927 if (mapping->start == saddr) in amdgpu_vm_bo_unmap()
1931 if (&mapping->list == &bo_va->invalids) in amdgpu_vm_bo_unmap()
1932 return -ENOENT; in amdgpu_vm_bo_unmap()
1935 list_del(&mapping->list); in amdgpu_vm_bo_unmap()
1936 amdgpu_vm_it_remove(mapping, &vm->va); in amdgpu_vm_bo_unmap()
1937 mapping->bo_va = NULL; in amdgpu_vm_bo_unmap()
1941 list_add(&mapping->list, &vm->freed); in amdgpu_vm_bo_unmap()
1944 bo_va->last_pt_update); in amdgpu_vm_bo_unmap()
1950 * amdgpu_vm_bo_clear_mappings - remove all mappings in a specific range
1976 eaddr = saddr + (size - 1) / AMDGPU_GPU_PAGE_SIZE; in amdgpu_vm_bo_clear_mappings()
1981 return -ENOMEM; in amdgpu_vm_bo_clear_mappings()
1982 INIT_LIST_HEAD(&before->list); in amdgpu_vm_bo_clear_mappings()
1987 return -ENOMEM; in amdgpu_vm_bo_clear_mappings()
1989 INIT_LIST_HEAD(&after->list); in amdgpu_vm_bo_clear_mappings()
1992 tmp = amdgpu_vm_it_iter_first(&vm->va, saddr, eaddr); in amdgpu_vm_bo_clear_mappings()
1995 if (tmp->start < saddr) { in amdgpu_vm_bo_clear_mappings()
1996 before->start = tmp->start; in amdgpu_vm_bo_clear_mappings()
1997 before->last = saddr - 1; in amdgpu_vm_bo_clear_mappings()
1998 before->offset = tmp->offset; in amdgpu_vm_bo_clear_mappings()
1999 before->flags = tmp->flags; in amdgpu_vm_bo_clear_mappings()
2000 before->bo_va = tmp->bo_va; in amdgpu_vm_bo_clear_mappings()
2001 list_add(&before->list, &tmp->bo_va->invalids); in amdgpu_vm_bo_clear_mappings()
2005 if (tmp->last > eaddr) { in amdgpu_vm_bo_clear_mappings()
2006 after->start = eaddr + 1; in amdgpu_vm_bo_clear_mappings()
2007 after->last = tmp->last; in amdgpu_vm_bo_clear_mappings()
2008 after->offset = tmp->offset; in amdgpu_vm_bo_clear_mappings()
2009 after->offset += (after->start - tmp->start) << PAGE_SHIFT; in amdgpu_vm_bo_clear_mappings()
2010 after->flags = tmp->flags; in amdgpu_vm_bo_clear_mappings()
2011 after->bo_va = tmp->bo_va; in amdgpu_vm_bo_clear_mappings()
2012 list_add(&after->list, &tmp->bo_va->invalids); in amdgpu_vm_bo_clear_mappings()
2015 list_del(&tmp->list); in amdgpu_vm_bo_clear_mappings()
2016 list_add(&tmp->list, &removed); in amdgpu_vm_bo_clear_mappings()
2023 amdgpu_vm_it_remove(tmp, &vm->va); in amdgpu_vm_bo_clear_mappings()
2024 list_del(&tmp->list); in amdgpu_vm_bo_clear_mappings()
2026 if (tmp->start < saddr) in amdgpu_vm_bo_clear_mappings()
2027 tmp->start = saddr; in amdgpu_vm_bo_clear_mappings()
2028 if (tmp->last > eaddr) in amdgpu_vm_bo_clear_mappings()
2029 tmp->last = eaddr; in amdgpu_vm_bo_clear_mappings()
2031 tmp->bo_va = NULL; in amdgpu_vm_bo_clear_mappings()
2032 list_add(&tmp->list, &vm->freed); in amdgpu_vm_bo_clear_mappings()
2037 if (!list_empty(&before->list)) { in amdgpu_vm_bo_clear_mappings()
2038 struct amdgpu_bo *bo = before->bo_va->base.bo; in amdgpu_vm_bo_clear_mappings()
2040 amdgpu_vm_it_insert(before, &vm->va); in amdgpu_vm_bo_clear_mappings()
2041 if (before->flags & AMDGPU_PTE_PRT_FLAG(adev)) in amdgpu_vm_bo_clear_mappings()
2045 !before->bo_va->base.moved) in amdgpu_vm_bo_clear_mappings()
2046 amdgpu_vm_bo_moved(&before->bo_va->base); in amdgpu_vm_bo_clear_mappings()
2052 if (!list_empty(&after->list)) { in amdgpu_vm_bo_clear_mappings()
2053 struct amdgpu_bo *bo = after->bo_va->base.bo; in amdgpu_vm_bo_clear_mappings()
2055 amdgpu_vm_it_insert(after, &vm->va); in amdgpu_vm_bo_clear_mappings()
2056 if (after->flags & AMDGPU_PTE_PRT_FLAG(adev)) in amdgpu_vm_bo_clear_mappings()
2060 !after->bo_va->base.moved) in amdgpu_vm_bo_clear_mappings()
2061 amdgpu_vm_bo_moved(&after->bo_va->base); in amdgpu_vm_bo_clear_mappings()
2070 * amdgpu_vm_bo_lookup_mapping - find mapping by address
2084 return amdgpu_vm_it_iter_first(&vm->va, addr, addr); in amdgpu_vm_bo_lookup_mapping()
2088 * amdgpu_vm_bo_trace_cs - trace all reserved mappings
2102 for (mapping = amdgpu_vm_it_iter_first(&vm->va, 0, U64_MAX); mapping; in amdgpu_vm_bo_trace_cs()
2104 if (mapping->bo_va && mapping->bo_va->base.bo) { in amdgpu_vm_bo_trace_cs()
2107 bo = mapping->bo_va->base.bo; in amdgpu_vm_bo_trace_cs()
2108 if (dma_resv_locking_ctx(bo->tbo.base.resv) != in amdgpu_vm_bo_trace_cs()
2118 * amdgpu_vm_bo_del - remove a bo from a specific vm
2123 * Remove @bo_va->bo from the requested vm.
2131 struct amdgpu_bo *bo = bo_va->base.bo; in amdgpu_vm_bo_del()
2132 struct amdgpu_vm *vm = bo_va->base.vm; in amdgpu_vm_bo_del()
2135 dma_resv_assert_held(vm->root.bo->tbo.base.resv); in amdgpu_vm_bo_del()
2138 dma_resv_assert_held(bo->tbo.base.resv); in amdgpu_vm_bo_del()
2140 ttm_bo_set_bulk_move(&bo->tbo, NULL); in amdgpu_vm_bo_del()
2142 for (base = &bo_va->base.bo->vm_bo; *base; in amdgpu_vm_bo_del()
2143 base = &(*base)->next) { in amdgpu_vm_bo_del()
2144 if (*base != &bo_va->base) in amdgpu_vm_bo_del()
2147 amdgpu_vm_update_stats(*base, bo->tbo.resource, -1); in amdgpu_vm_bo_del()
2148 *base = bo_va->base.next; in amdgpu_vm_bo_del()
2153 spin_lock(&vm->status_lock); in amdgpu_vm_bo_del()
2154 list_del(&bo_va->base.vm_status); in amdgpu_vm_bo_del()
2155 spin_unlock(&vm->status_lock); in amdgpu_vm_bo_del()
2157 list_for_each_entry_safe(mapping, next, &bo_va->valids, list) { in amdgpu_vm_bo_del()
2158 list_del(&mapping->list); in amdgpu_vm_bo_del()
2159 amdgpu_vm_it_remove(mapping, &vm->va); in amdgpu_vm_bo_del()
2160 mapping->bo_va = NULL; in amdgpu_vm_bo_del()
2162 list_add(&mapping->list, &vm->freed); in amdgpu_vm_bo_del()
2164 list_for_each_entry_safe(mapping, next, &bo_va->invalids, list) { in amdgpu_vm_bo_del()
2165 list_del(&mapping->list); in amdgpu_vm_bo_del()
2166 amdgpu_vm_it_remove(mapping, &vm->va); in amdgpu_vm_bo_del()
2168 bo_va->last_pt_update); in amdgpu_vm_bo_del()
2171 dma_fence_put(bo_va->last_pt_update); in amdgpu_vm_bo_del()
2173 if (bo && bo_va->is_xgmi) in amdgpu_vm_bo_del()
2180 * amdgpu_vm_evictable - check if we can evict a VM
2188 struct amdgpu_vm_bo_base *bo_base = bo->vm_bo; in amdgpu_vm_evictable()
2191 if (!bo_base || !bo_base->vm) in amdgpu_vm_evictable()
2195 if (!dma_resv_test_signaled(bo->tbo.base.resv, DMA_RESV_USAGE_BOOKKEEP)) in amdgpu_vm_evictable()
2199 if (!amdgpu_vm_eviction_trylock(bo_base->vm)) in amdgpu_vm_evictable()
2203 if (!dma_fence_is_signaled(bo_base->vm->last_unlocked)) { in amdgpu_vm_evictable()
2204 amdgpu_vm_eviction_unlock(bo_base->vm); in amdgpu_vm_evictable()
2208 bo_base->vm->evicting = true; in amdgpu_vm_evictable()
2209 amdgpu_vm_eviction_unlock(bo_base->vm); in amdgpu_vm_evictable()
2214 * amdgpu_vm_bo_invalidate - mark the bo as invalid
2225 for (bo_base = bo->vm_bo; bo_base; bo_base = bo_base->next) { in amdgpu_vm_bo_invalidate()
2226 struct amdgpu_vm *vm = bo_base->vm; in amdgpu_vm_bo_invalidate()
2233 if (bo_base->moved) in amdgpu_vm_bo_invalidate()
2235 bo_base->moved = true; in amdgpu_vm_bo_invalidate()
2237 if (bo->tbo.type == ttm_bo_type_kernel) in amdgpu_vm_bo_invalidate()
2247 * amdgpu_vm_bo_move - handle BO move
2260 for (bo_base = bo->vm_bo; bo_base; bo_base = bo_base->next) { in amdgpu_vm_bo_move()
2261 struct amdgpu_vm *vm = bo_base->vm; in amdgpu_vm_bo_move()
2263 spin_lock(&vm->status_lock); in amdgpu_vm_bo_move()
2264 amdgpu_vm_update_stats_locked(bo_base, bo->tbo.resource, -1); in amdgpu_vm_bo_move()
2266 spin_unlock(&vm->status_lock); in amdgpu_vm_bo_move()
2273 * amdgpu_vm_get_block_size - calculate VM page table size as power of two
2288 return (bits - 9); in amdgpu_vm_get_block_size()
2294 * amdgpu_vm_adjust_size - adjust vm size, block size and fragment size
2307 unsigned int max_size = 1 << (max_bits - 30); in amdgpu_vm_adjust_size()
2312 if (amdgpu_vm_size != -1) { in amdgpu_vm_adjust_size()
2315 dev_warn(adev->dev, "VM size (%d) too large, max is %u GB\n", in amdgpu_vm_adjust_size()
2327 * - Need to map system memory and VRAM from all GPUs in amdgpu_vm_adjust_size()
2328 * - VRAM from other GPUs not known here in amdgpu_vm_adjust_size()
2329 * - Assume VRAM <= system memory in amdgpu_vm_adjust_size()
2330 * - On GFX8 and older, VM space can be segmented for in amdgpu_vm_adjust_size()
2332 * - Need to allow room for fragmentation, guard pages etc. in amdgpu_vm_adjust_size()
2340 (1 << 30) - 1) >> 30; in amdgpu_vm_adjust_size()
2345 adev->vm_manager.max_pfn = (uint64_t)vm_size << 18; in amdgpu_vm_adjust_size()
2347 tmp = roundup_pow_of_two(adev->vm_manager.max_pfn); in amdgpu_vm_adjust_size()
2348 if (amdgpu_vm_block_size != -1) in amdgpu_vm_adjust_size()
2349 tmp >>= amdgpu_vm_block_size - 9; in amdgpu_vm_adjust_size()
2350 tmp = DIV_ROUND_UP(fls64(tmp) - 1, 9) - 1; in amdgpu_vm_adjust_size()
2351 adev->vm_manager.num_level = min_t(unsigned int, max_level, tmp); in amdgpu_vm_adjust_size()
2352 switch (adev->vm_manager.num_level) { in amdgpu_vm_adjust_size()
2354 adev->vm_manager.root_level = AMDGPU_VM_PDB2; in amdgpu_vm_adjust_size()
2357 adev->vm_manager.root_level = AMDGPU_VM_PDB1; in amdgpu_vm_adjust_size()
2360 adev->vm_manager.root_level = AMDGPU_VM_PDB0; in amdgpu_vm_adjust_size()
2363 dev_err(adev->dev, "VMPT only supports 2~4+1 levels\n"); in amdgpu_vm_adjust_size()
2366 if (amdgpu_vm_block_size != -1) in amdgpu_vm_adjust_size()
2367 adev->vm_manager.block_size = in amdgpu_vm_adjust_size()
2369 - AMDGPU_GPU_PAGE_SHIFT in amdgpu_vm_adjust_size()
2370 - 9 * adev->vm_manager.num_level); in amdgpu_vm_adjust_size()
2371 else if (adev->vm_manager.num_level > 1) in amdgpu_vm_adjust_size()
2372 adev->vm_manager.block_size = 9; in amdgpu_vm_adjust_size()
2374 adev->vm_manager.block_size = amdgpu_vm_get_block_size(tmp); in amdgpu_vm_adjust_size()
2376 if (amdgpu_vm_fragment_size == -1) in amdgpu_vm_adjust_size()
2377 adev->vm_manager.fragment_size = fragment_size_default; in amdgpu_vm_adjust_size()
2379 adev->vm_manager.fragment_size = amdgpu_vm_fragment_size; in amdgpu_vm_adjust_size()
2381 DRM_INFO("vm size is %u GB, %u levels, block size is %u-bit, fragment size is %u-bit\n", in amdgpu_vm_adjust_size()
2382 vm_size, adev->vm_manager.num_level + 1, in amdgpu_vm_adjust_size()
2383 adev->vm_manager.block_size, in amdgpu_vm_adjust_size()
2384 adev->vm_manager.fragment_size); in amdgpu_vm_adjust_size()
2388 * amdgpu_vm_wait_idle - wait for the VM to become idle
2395 timeout = dma_resv_wait_timeout(vm->root.bo->tbo.base.resv, in amdgpu_vm_wait_idle()
2401 return dma_fence_wait_timeout(vm->last_unlocked, true, timeout); in amdgpu_vm_wait_idle()
2417 xa_lock_irqsave(&adev->vm_manager.pasids, flags); in amdgpu_vm_get_vm_from_pasid()
2418 vm = xa_load(&adev->vm_manager.pasids, pasid); in amdgpu_vm_get_vm_from_pasid()
2419 xa_unlock_irqrestore(&adev->vm_manager.pasids, flags); in amdgpu_vm_get_vm_from_pasid()
2425 * amdgpu_vm_put_task_info - reference down the vm task_info ptr
2433 kref_put(&task_info->refcount, amdgpu_vm_destroy_task_info); in amdgpu_vm_put_task_info()
2437 * amdgpu_vm_get_task_info_vm - Extracts task info for a vm.
2450 ti = vm->task_info; in amdgpu_vm_get_task_info_vm()
2451 kref_get(&vm->task_info->refcount); in amdgpu_vm_get_task_info_vm()
2458 * amdgpu_vm_get_task_info_pasid - Extracts task info for a PASID.
2475 vm->task_info = kzalloc(sizeof(struct amdgpu_task_info), GFP_KERNEL); in amdgpu_vm_create_task_info()
2476 if (!vm->task_info) in amdgpu_vm_create_task_info()
2477 return -ENOMEM; in amdgpu_vm_create_task_info()
2479 kref_init(&vm->task_info->refcount); in amdgpu_vm_create_task_info()
2484 * amdgpu_vm_set_task_info - Sets VMs task info.
2490 if (!vm->task_info) in amdgpu_vm_set_task_info()
2493 if (vm->task_info->pid == current->pid) in amdgpu_vm_set_task_info()
2496 vm->task_info->pid = current->pid; in amdgpu_vm_set_task_info()
2497 get_task_comm(vm->task_info->task_name, current); in amdgpu_vm_set_task_info()
2499 if (current->group_leader->mm != current->mm) in amdgpu_vm_set_task_info()
2502 vm->task_info->tgid = current->group_leader->pid; in amdgpu_vm_set_task_info()
2503 get_task_comm(vm->task_info->process_name, current->group_leader); in amdgpu_vm_set_task_info()
2507 * amdgpu_vm_init - initialize a vm instance
2525 vm->va = RB_ROOT_CACHED; in amdgpu_vm_init()
2527 vm->reserved_vmid[i] = NULL; in amdgpu_vm_init()
2528 INIT_LIST_HEAD(&vm->evicted); in amdgpu_vm_init()
2529 INIT_LIST_HEAD(&vm->evicted_user); in amdgpu_vm_init()
2530 INIT_LIST_HEAD(&vm->relocated); in amdgpu_vm_init()
2531 INIT_LIST_HEAD(&vm->moved); in amdgpu_vm_init()
2532 INIT_LIST_HEAD(&vm->idle); in amdgpu_vm_init()
2533 INIT_LIST_HEAD(&vm->invalidated); in amdgpu_vm_init()
2534 spin_lock_init(&vm->status_lock); in amdgpu_vm_init()
2535 INIT_LIST_HEAD(&vm->freed); in amdgpu_vm_init()
2536 INIT_LIST_HEAD(&vm->done); in amdgpu_vm_init()
2537 INIT_LIST_HEAD(&vm->pt_freed); in amdgpu_vm_init()
2538 INIT_WORK(&vm->pt_free_work, amdgpu_vm_pt_free_work); in amdgpu_vm_init()
2539 INIT_KFIFO(vm->faults); in amdgpu_vm_init()
2545 ttm_lru_bulk_move_init(&vm->lru_bulk_move); in amdgpu_vm_init()
2547 vm->is_compute_context = false; in amdgpu_vm_init()
2549 vm->use_cpu_for_update = !!(adev->vm_manager.vm_update_mode & in amdgpu_vm_init()
2553 vm->use_cpu_for_update ? "CPU" : "SDMA"); in amdgpu_vm_init()
2554 WARN_ONCE((vm->use_cpu_for_update && in amdgpu_vm_init()
2555 !amdgpu_gmc_vram_full_visible(&adev->gmc)), in amdgpu_vm_init()
2558 if (vm->use_cpu_for_update) in amdgpu_vm_init()
2559 vm->update_funcs = &amdgpu_vm_cpu_funcs; in amdgpu_vm_init()
2561 vm->update_funcs = &amdgpu_vm_sdma_funcs; in amdgpu_vm_init()
2563 vm->last_update = dma_fence_get_stub(); in amdgpu_vm_init()
2564 vm->last_unlocked = dma_fence_get_stub(); in amdgpu_vm_init()
2565 vm->last_tlb_flush = dma_fence_get_stub(); in amdgpu_vm_init()
2566 vm->generation = amdgpu_vm_generation(adev, NULL); in amdgpu_vm_init()
2568 mutex_init(&vm->eviction_lock); in amdgpu_vm_init()
2569 vm->evicting = false; in amdgpu_vm_init()
2570 vm->tlb_fence_context = dma_fence_context_alloc(1); in amdgpu_vm_init()
2572 r = amdgpu_vm_pt_create(adev, vm, adev->vm_manager.root_level, in amdgpu_vm_init()
2577 root_bo = amdgpu_bo_ref(&root->bo); in amdgpu_vm_init()
2584 amdgpu_vm_bo_base_init(&vm->root, vm, root_bo); in amdgpu_vm_init()
2585 r = dma_resv_reserve_fences(root_bo->tbo.base.resv, 1); in amdgpu_vm_init()
2597 amdgpu_bo_unreserve(vm->root.bo); in amdgpu_vm_init()
2604 amdgpu_bo_unreserve(vm->root.bo); in amdgpu_vm_init()
2608 dma_fence_put(vm->last_tlb_flush); in amdgpu_vm_init()
2609 dma_fence_put(vm->last_unlocked); in amdgpu_vm_init()
2610 ttm_lru_bulk_move_fini(&adev->mman.bdev, &vm->lru_bulk_move); in amdgpu_vm_init()
2617 * amdgpu_vm_make_compute - Turn a GFX VM into a compute VM
2622 * This only works on GFX VMs that don't have any BOs added and no
2626 * - use_cpu_for_update
2627 * - pte_supports_ats
2633 * 0 for success, -errno for errors.
2639 r = amdgpu_bo_reserve(vm->root.bo, true); in amdgpu_vm_make_compute()
2644 vm->use_cpu_for_update = !!(adev->vm_manager.vm_update_mode & in amdgpu_vm_make_compute()
2647 vm->use_cpu_for_update ? "CPU" : "SDMA"); in amdgpu_vm_make_compute()
2648 WARN_ONCE((vm->use_cpu_for_update && in amdgpu_vm_make_compute()
2649 !amdgpu_gmc_vram_full_visible(&adev->gmc)), in amdgpu_vm_make_compute()
2652 if (vm->use_cpu_for_update) { in amdgpu_vm_make_compute()
2654 r = amdgpu_bo_sync_wait(vm->root.bo, in amdgpu_vm_make_compute()
2659 vm->update_funcs = &amdgpu_vm_cpu_funcs; in amdgpu_vm_make_compute()
2665 vm->update_funcs = &amdgpu_vm_sdma_funcs; in amdgpu_vm_make_compute()
2668 dma_fence_put(vm->last_update); in amdgpu_vm_make_compute()
2669 vm->last_update = dma_fence_get_stub(); in amdgpu_vm_make_compute()
2670 vm->is_compute_context = true; in amdgpu_vm_make_compute()
2673 amdgpu_bo_unreserve(vm->root.bo); in amdgpu_vm_make_compute()
2678 * amdgpu_vm_release_compute - release a compute vm
2688 vm->is_compute_context = false; in amdgpu_vm_release_compute()
2694 if (!(drm_memory_stats_is_zero(&vm->stats[i].drm) && in amdgpu_vm_stats_is_zero()
2695 vm->stats[i].evicted == 0)) in amdgpu_vm_stats_is_zero()
2702 * amdgpu_vm_fini - tear down a vm instance
2713 bool prt_fini_needed = !!adev->gmc.gmc_funcs->set_prt; in amdgpu_vm_fini()
2720 flush_work(&vm->pt_free_work); in amdgpu_vm_fini()
2722 root = amdgpu_bo_ref(vm->root.bo); in amdgpu_vm_fini()
2725 dma_fence_wait(vm->last_unlocked, false); in amdgpu_vm_fini()
2726 dma_fence_put(vm->last_unlocked); in amdgpu_vm_fini()
2727 dma_fence_wait(vm->last_tlb_flush, false); in amdgpu_vm_fini()
2729 spin_lock_irqsave(vm->last_tlb_flush->lock, flags); in amdgpu_vm_fini()
2730 spin_unlock_irqrestore(vm->last_tlb_flush->lock, flags); in amdgpu_vm_fini()
2731 dma_fence_put(vm->last_tlb_flush); in amdgpu_vm_fini()
2733 list_for_each_entry_safe(mapping, tmp, &vm->freed, list) { in amdgpu_vm_fini()
2734 if (mapping->flags & AMDGPU_PTE_PRT_FLAG(adev) && prt_fini_needed) { in amdgpu_vm_fini()
2739 list_del(&mapping->list); in amdgpu_vm_fini()
2746 WARN_ON(vm->root.bo); in amdgpu_vm_fini()
2750 if (!RB_EMPTY_ROOT(&vm->va.rb_root)) { in amdgpu_vm_fini()
2751 dev_err(adev->dev, "still active bo inside vm\n"); in amdgpu_vm_fini()
2754 &vm->va.rb_root, rb) { in amdgpu_vm_fini()
2758 list_del(&mapping->list); in amdgpu_vm_fini()
2762 dma_fence_put(vm->last_update); in amdgpu_vm_fini()
2765 if (vm->reserved_vmid[i]) { in amdgpu_vm_fini()
2767 vm->reserved_vmid[i] = false; in amdgpu_vm_fini()
2771 ttm_lru_bulk_move_fini(&adev->mman.bdev, &vm->lru_bulk_move); in amdgpu_vm_fini()
2774 struct amdgpu_task_info *ti = vm->task_info; in amdgpu_vm_fini()
2776 dev_warn(adev->dev, in amdgpu_vm_fini()
2777 "VM memory stats for proc %s(%d) task %s(%d) is non-zero when fini\n", in amdgpu_vm_fini()
2778 ti->process_name, ti->pid, ti->task_name, ti->tgid); in amdgpu_vm_fini()
2781 amdgpu_vm_put_task_info(vm->task_info); in amdgpu_vm_fini()
2785 * amdgpu_vm_manager_init - init the VM manager
2798 adev->vm_manager.concurrent_flush = !(adev->asic_type < CHIP_VEGA10 || in amdgpu_vm_manager_init()
2799 adev->asic_type == CHIP_NAVI10 || in amdgpu_vm_manager_init()
2800 adev->asic_type == CHIP_NAVI14); in amdgpu_vm_manager_init()
2803 adev->vm_manager.fence_context = in amdgpu_vm_manager_init()
2806 adev->vm_manager.seqno[i] = 0; in amdgpu_vm_manager_init()
2808 spin_lock_init(&adev->vm_manager.prt_lock); in amdgpu_vm_manager_init()
2809 atomic_set(&adev->vm_manager.num_prt_users, 0); in amdgpu_vm_manager_init()
2815 if (amdgpu_vm_update_mode == -1) { in amdgpu_vm_manager_init()
2819 if (amdgpu_gmc_vram_full_visible(&adev->gmc) && in amdgpu_vm_manager_init()
2821 adev->vm_manager.vm_update_mode = in amdgpu_vm_manager_init()
2824 adev->vm_manager.vm_update_mode = 0; in amdgpu_vm_manager_init()
2826 adev->vm_manager.vm_update_mode = amdgpu_vm_update_mode; in amdgpu_vm_manager_init()
2828 adev->vm_manager.vm_update_mode = 0; in amdgpu_vm_manager_init()
2831 xa_init_flags(&adev->vm_manager.pasids, XA_FLAGS_LOCK_IRQ); in amdgpu_vm_manager_init()
2835 * amdgpu_vm_manager_fini - cleanup VM manager
2843 WARN_ON(!xa_empty(&adev->vm_manager.pasids)); in amdgpu_vm_manager_fini()
2844 xa_destroy(&adev->vm_manager.pasids); in amdgpu_vm_manager_fini()
2850 * amdgpu_vm_ioctl - Manages VMID reservation for vm hubs.
2857 * 0 for success, -errno for errors.
2863 struct amdgpu_fpriv *fpriv = filp->driver_priv; in amdgpu_vm_ioctl()
2866 if (args->in.flags) in amdgpu_vm_ioctl()
2867 return -EINVAL; in amdgpu_vm_ioctl()
2869 switch (args->in.op) { in amdgpu_vm_ioctl()
2872 if (!fpriv->vm.reserved_vmid[AMDGPU_GFXHUB(0)]) { in amdgpu_vm_ioctl()
2874 fpriv->vm.reserved_vmid[AMDGPU_GFXHUB(0)] = true; in amdgpu_vm_ioctl()
2879 if (fpriv->vm.reserved_vmid[AMDGPU_GFXHUB(0)]) { in amdgpu_vm_ioctl()
2881 fpriv->vm.reserved_vmid[AMDGPU_GFXHUB(0)] = false; in amdgpu_vm_ioctl()
2885 return -EINVAL; in amdgpu_vm_ioctl()
2892 * amdgpu_vm_handle_fault - graceful handling of VM faults.
2896 * @vmid: VMID, only used for GFX 9.4.3.
2898 * GFX 9.4.3.
2916 xa_lock_irqsave(&adev->vm_manager.pasids, irqflags); in amdgpu_vm_handle_fault()
2917 vm = xa_load(&adev->vm_manager.pasids, pasid); in amdgpu_vm_handle_fault()
2919 root = amdgpu_bo_ref(vm->root.bo); in amdgpu_vm_handle_fault()
2920 is_compute_context = vm->is_compute_context; in amdgpu_vm_handle_fault()
2924 xa_unlock_irqrestore(&adev->vm_manager.pasids, irqflags); in amdgpu_vm_handle_fault()
2942 xa_lock_irqsave(&adev->vm_manager.pasids, irqflags); in amdgpu_vm_handle_fault()
2943 vm = xa_load(&adev->vm_manager.pasids, pasid); in amdgpu_vm_handle_fault()
2944 if (vm && vm->root.bo != root) in amdgpu_vm_handle_fault()
2946 xa_unlock_irqrestore(&adev->vm_manager.pasids, irqflags); in amdgpu_vm_handle_fault()
2955 * combination to force a no-retry-fault in amdgpu_vm_handle_fault()
2961 value = adev->dummy_page_addr; in amdgpu_vm_handle_fault()
2970 r = dma_resv_reserve_fences(root->tbo.base.resv, 1); in amdgpu_vm_handle_fault()
2996 * amdgpu_debugfs_vm_bo_info - print BO info for the VM
3020 spin_lock(&vm->status_lock); in amdgpu_debugfs_vm_bo_info()
3022 list_for_each_entry_safe(bo_va, tmp, &vm->idle, base.vm_status) { in amdgpu_debugfs_vm_bo_info()
3023 if (!bo_va->base.bo) in amdgpu_debugfs_vm_bo_info()
3025 total_idle += amdgpu_bo_print_info(id++, bo_va->base.bo, m); in amdgpu_debugfs_vm_bo_info()
3031 list_for_each_entry_safe(bo_va, tmp, &vm->evicted, base.vm_status) { in amdgpu_debugfs_vm_bo_info()
3032 if (!bo_va->base.bo) in amdgpu_debugfs_vm_bo_info()
3034 total_evicted += amdgpu_bo_print_info(id++, bo_va->base.bo, m); in amdgpu_debugfs_vm_bo_info()
3040 list_for_each_entry_safe(bo_va, tmp, &vm->relocated, base.vm_status) { in amdgpu_debugfs_vm_bo_info()
3041 if (!bo_va->base.bo) in amdgpu_debugfs_vm_bo_info()
3043 total_relocated += amdgpu_bo_print_info(id++, bo_va->base.bo, m); in amdgpu_debugfs_vm_bo_info()
3049 list_for_each_entry_safe(bo_va, tmp, &vm->moved, base.vm_status) { in amdgpu_debugfs_vm_bo_info()
3050 if (!bo_va->base.bo) in amdgpu_debugfs_vm_bo_info()
3052 total_moved += amdgpu_bo_print_info(id++, bo_va->base.bo, m); in amdgpu_debugfs_vm_bo_info()
3058 list_for_each_entry_safe(bo_va, tmp, &vm->invalidated, base.vm_status) { in amdgpu_debugfs_vm_bo_info()
3059 if (!bo_va->base.bo) in amdgpu_debugfs_vm_bo_info()
3061 total_invalidated += amdgpu_bo_print_info(id++, bo_va->base.bo, m); in amdgpu_debugfs_vm_bo_info()
3067 list_for_each_entry_safe(bo_va, tmp, &vm->done, base.vm_status) { in amdgpu_debugfs_vm_bo_info()
3068 if (!bo_va->base.bo) in amdgpu_debugfs_vm_bo_info()
3070 total_done += amdgpu_bo_print_info(id++, bo_va->base.bo, m); in amdgpu_debugfs_vm_bo_info()
3072 spin_unlock(&vm->status_lock); in amdgpu_debugfs_vm_bo_info()
3091 * amdgpu_vm_update_fault_cache - update cached fault into.
3109 xa_lock_irqsave(&adev->vm_manager.pasids, flags); in amdgpu_vm_update_fault_cache()
3111 vm = xa_load(&adev->vm_manager.pasids, pasid); in amdgpu_vm_update_fault_cache()
3115 * only update if status is non-0. in amdgpu_vm_update_fault_cache()
3118 vm->fault_info.addr = addr; in amdgpu_vm_update_fault_cache()
3119 vm->fault_info.status = status; in amdgpu_vm_update_fault_cache()
3124 adev->vm_manager.fault_info.addr = addr; in amdgpu_vm_update_fault_cache()
3125 adev->vm_manager.fault_info.vmhub = vmhub; in amdgpu_vm_update_fault_cache()
3126 adev->vm_manager.fault_info.status = status; in amdgpu_vm_update_fault_cache()
3129 vm->fault_info.vmhub = AMDGPU_VMHUB_TYPE_GFX; in amdgpu_vm_update_fault_cache()
3130 vm->fault_info.vmhub |= in amdgpu_vm_update_fault_cache()
3131 (vmhub - AMDGPU_GFXHUB_START) << AMDGPU_VMHUB_IDX_SHIFT; in amdgpu_vm_update_fault_cache()
3133 vm->fault_info.vmhub = AMDGPU_VMHUB_TYPE_MM0; in amdgpu_vm_update_fault_cache()
3134 vm->fault_info.vmhub |= in amdgpu_vm_update_fault_cache()
3135 (vmhub - AMDGPU_MMHUB0_START) << AMDGPU_VMHUB_IDX_SHIFT; in amdgpu_vm_update_fault_cache()
3137 vm->fault_info.vmhub = AMDGPU_VMHUB_TYPE_MM1; in amdgpu_vm_update_fault_cache()
3138 vm->fault_info.vmhub |= in amdgpu_vm_update_fault_cache()
3139 (vmhub - AMDGPU_MMHUB1_START) << AMDGPU_VMHUB_IDX_SHIFT; in amdgpu_vm_update_fault_cache()
3144 xa_unlock_irqrestore(&adev->vm_manager.pasids, flags); in amdgpu_vm_update_fault_cache()
3148 * amdgpu_vm_is_bo_always_valid - check if the BO is VM always valid
3158 return bo && bo->tbo.base.resv == vm->root.bo->tbo.base.resv; in amdgpu_vm_is_bo_always_valid()