From d13c256d5ee11da1664377481543005142d9bd30 Mon Sep 17 00:00:00 2001 From: Alex Waterman Date: Tue, 17 Oct 2017 10:55:00 -0700 Subject: gpu: nvgpu: VM unmap refactoring Re-organize the unmap code to be better split between OS specific requirements and common core requirements. The new code flow works as follows: nvgpu_vm_unmap() Is the primary entrance to the unmap path. It takes a VM and a GPU virtual address to unmap. There's also an optional batch mapping struct. This function is responsible for making sure there is a real buffer and that if it's being called on a fixed mapping then the mapping will definitely be freed (since buffers are ref-counted). Then this function decrements the ref-count and returns. If the ref-count hits zero then __nvgpu_vm_unmap_ref() is called which just calls __nvgpu_vm_unmap() with the relevant batch struct if present. This is where the real work is done. __nvgpu_vm_unmap() clears the GMMU mapping, removes the mapped buffer from the various lists and trees it may be in and then calls the nvgpu_vm_unmap_system() function. This function handles any OS specific stuff and must be defined by all VM OS implementations. There's a a short cut used by some other core VM code to free mappings without going through nvgpu_vm_map(). Mostly they just directly decrement the mapping ref-count which can then call __nvgpu_vm_unmap_ref() if the ref-count hits zero. JIRA NVGPU-30 JIRA NVGPU-71 Change-Id: Ic626d37ab936819841bab45214f027b40ffa4e5a Signed-off-by: Alex Waterman Reviewed-on: https://git-master.nvidia.com/r/1583982 Reviewed-by: Automatic_Commit_Validation_User GVS: Gerrit_Virtual_Submit Reviewed-by: Terje Bergstrom Reviewed-by: mobile promotions Tested-by: mobile promotions --- drivers/gpu/nvgpu/common/linux/cde.c | 4 +- drivers/gpu/nvgpu/common/linux/ioctl_as.c | 10 ++-- drivers/gpu/nvgpu/common/linux/ioctl_dbg.c | 4 +- drivers/gpu/nvgpu/common/linux/vm.c | 84 +++--------------------------- 4 files changed, 17 insertions(+), 85 deletions(-) (limited to 'drivers/gpu/nvgpu/common/linux') diff --git a/drivers/gpu/nvgpu/common/linux/cde.c b/drivers/gpu/nvgpu/common/linux/cde.c index 65c50726..2f2e886f 100644 --- a/drivers/gpu/nvgpu/common/linux/cde.c +++ b/drivers/gpu/nvgpu/common/linux/cde.c @@ -1167,7 +1167,7 @@ __releases(&l->cde_app->mutex) cde_ctx->init_cmd_executed = true; /* unmap the buffers - channel holds references to them now */ - nvgpu_vm_unmap(cde_ctx->vm, map_vaddr); + nvgpu_vm_unmap(cde_ctx->vm, map_vaddr, NULL); return err; @@ -1175,7 +1175,7 @@ exit_unmap_surface: if (surface) dma_buf_vunmap(compbits_scatter_buf, surface); exit_unmap_vaddr: - nvgpu_vm_unmap(cde_ctx->vm, map_vaddr); + nvgpu_vm_unmap(cde_ctx->vm, map_vaddr, NULL); exit_idle: gk20a_idle(g); return err; diff --git a/drivers/gpu/nvgpu/common/linux/ioctl_as.c b/drivers/gpu/nvgpu/common/linux/ioctl_as.c index 08064370..18d0dd07 100644 --- a/drivers/gpu/nvgpu/common/linux/ioctl_as.c +++ b/drivers/gpu/nvgpu/common/linux/ioctl_as.c @@ -118,7 +118,10 @@ static int gk20a_as_ioctl_unmap_buffer( struct nvgpu_as_unmap_buffer_args *args) { gk20a_dbg_fn(""); - return nvgpu_vm_unmap_buffer(as_share->vm, args->offset, NULL); + + nvgpu_vm_unmap(as_share->vm, args->offset, NULL); + + return 0; } static int gk20a_as_ioctl_map_buffer_batch( @@ -155,10 +158,7 @@ static int gk20a_as_ioctl_map_buffer_batch( break; } - err = nvgpu_vm_unmap_buffer(as_share->vm, unmap_args.offset, - &batch); - if (err) - break; + nvgpu_vm_unmap(as_share->vm, unmap_args.offset, &batch); } if (err) { diff --git a/drivers/gpu/nvgpu/common/linux/ioctl_dbg.c b/drivers/gpu/nvgpu/common/linux/ioctl_dbg.c index 403d9261..24bf813a 100644 --- a/drivers/gpu/nvgpu/common/linux/ioctl_dbg.c +++ b/drivers/gpu/nvgpu/common/linux/ioctl_dbg.c @@ -1142,7 +1142,7 @@ static int gk20a_perfbuf_map(struct dbg_session_gk20a *dbg_s, return 0; err_unmap: - nvgpu_vm_unmap_buffer(mm->perfbuf.vm, args->offset, NULL); + nvgpu_vm_unmap(mm->perfbuf.vm, args->offset, NULL); err_remove_vm: nvgpu_vm_put(mm->perfbuf.vm); nvgpu_mutex_release(&g->dbg_sessions_lock); @@ -1386,7 +1386,7 @@ static int gk20a_perfbuf_release_locked(struct gk20a *g, u64 offset) err = g->ops.dbg_session_ops.perfbuffer_disable(g); - nvgpu_vm_unmap_buffer(vm, offset, NULL); + nvgpu_vm_unmap(vm, offset, NULL); nvgpu_free_inst_block(g, &mm->perfbuf.inst_block); nvgpu_vm_put(vm); diff --git a/drivers/gpu/nvgpu/common/linux/vm.c b/drivers/gpu/nvgpu/common/linux/vm.c index 984c2015..feb124f8 100644 --- a/drivers/gpu/nvgpu/common/linux/vm.c +++ b/drivers/gpu/nvgpu/common/linux/vm.c @@ -641,88 +641,20 @@ int nvgpu_vm_map_buffer(struct vm_gk20a *vm, return err; } -int nvgpu_vm_unmap_buffer(struct vm_gk20a *vm, u64 offset, - struct vm_gk20a_mapping_batch *batch) -{ - struct gk20a *g = vm->mm->g; - struct nvgpu_mapped_buf *mapped_buffer; - - nvgpu_mutex_acquire(&vm->update_gmmu_lock); - - mapped_buffer = __nvgpu_vm_find_mapped_buf(vm, offset); - if (!mapped_buffer) { - nvgpu_mutex_release(&vm->update_gmmu_lock); - nvgpu_err(g, "invalid addr to unmap 0x%llx", offset); - return 0; - } - - if (mapped_buffer->flags & NVGPU_AS_MAP_BUFFER_FLAGS_FIXED_OFFSET) { - struct nvgpu_timeout timeout; - - nvgpu_mutex_release(&vm->update_gmmu_lock); - - nvgpu_timeout_init(vm->mm->g, &timeout, 10000, - NVGPU_TIMER_RETRY_TIMER); - do { - if (nvgpu_atomic_read( - &mapped_buffer->ref.refcount) == 1) - break; - nvgpu_udelay(5); - } while (!nvgpu_timeout_expired_msg(&timeout, - "sync-unmap failed on 0x%llx")); - - nvgpu_mutex_acquire(&vm->update_gmmu_lock); - } - - if (mapped_buffer->user_mapped == 0) { - nvgpu_mutex_release(&vm->update_gmmu_lock); - nvgpu_err(g, "addr already unmapped from user 0x%llx", offset); - return 0; - } - - mapped_buffer->user_mapped--; - if (mapped_buffer->user_mapped == 0) - vm->num_user_mapped_buffers--; - - vm->kref_put_batch = batch; - nvgpu_ref_put(&mapped_buffer->ref, nvgpu_vm_unmap_locked_ref); - vm->kref_put_batch = NULL; - - nvgpu_mutex_release(&vm->update_gmmu_lock); - return 0; -} - -/* NOTE! mapped_buffers lock must be held */ -void nvgpu_vm_unmap_locked(struct nvgpu_mapped_buf *mapped_buffer, - struct vm_gk20a_mapping_batch *batch) +/* + * This is the function call-back for freeing OS specific components of an + * nvgpu_mapped_buf. This should most likely never be called outside of the + * core MM framework! + * + * Note: the VM lock will be held. + */ +void nvgpu_vm_unmap_system(struct nvgpu_mapped_buf *mapped_buffer) { struct vm_gk20a *vm = mapped_buffer->vm; - struct gk20a *g = vm->mm->g; - - g->ops.mm.gmmu_unmap(vm, - mapped_buffer->addr, - mapped_buffer->size, - mapped_buffer->pgsz_idx, - mapped_buffer->va_allocated, - gk20a_mem_flag_none, - mapped_buffer->vm_area ? - mapped_buffer->vm_area->sparse : false, - batch); gk20a_mm_unpin(dev_from_vm(vm), mapped_buffer->dmabuf, mapped_buffer->sgt); - /* remove from mapped buffer tree and remove list, free */ - nvgpu_remove_mapped_buf(vm, mapped_buffer); - if (!nvgpu_list_empty(&mapped_buffer->buffer_list)) - nvgpu_list_del(&mapped_buffer->buffer_list); - - /* keep track of mapped buffers */ - if (mapped_buffer->user_mapped) - vm->num_user_mapped_buffers--; - if (mapped_buffer->own_mem_ref) dma_buf_put(mapped_buffer->dmabuf); - - nvgpu_kfree(g, mapped_buffer); } -- cgit v1.2.2