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 <alexw@nvidia.com>
Reviewed-on: https://git-master.nvidia.com/r/1583982
Reviewed-by: Automatic_Commit_Validation_User
GVS: Gerrit_Virtual_Submit
Reviewed-by: Terje Bergstrom <tbergstrom@nvidia.com>
Reviewed-by: mobile promotions <svcmobile_promotions@nvidia.com>
Tested-by: mobile promotions <svcmobile_promotions@nvidia.com>

4 files changed, 17 insertions, 85 deletions

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);
 }