9 files changed, 72 insertions, 90 deletions

diff --git a/drivers/gpu/nvgpu/common/mm/vm.c b/drivers/gpu/nvgpu/common/mm/vm.c
index e42c7c5a..bdc8554c 100644
--- a/drivers/gpu/nvgpu/common/mm/vm.c
+++ b/drivers/gpu/nvgpu/common/mm/vm.c
@@ -442,7 +442,22 @@ clean_up_page_tables:
         return err;
 }
 
-void nvgpu_vm_remove_support_nofree(struct vm_gk20a *vm)
+void nvgpu_deinit_vm(struct vm_gk20a *vm)
+{
+        if (nvgpu_alloc_initialized(&vm->kernel))
+                nvgpu_alloc_destroy(&vm->kernel);
+        if (nvgpu_alloc_initialized(&vm->user))
+                nvgpu_alloc_destroy(&vm->user);
+        if (nvgpu_alloc_initialized(&vm->user_lp))
+                nvgpu_alloc_destroy(&vm->user_lp);
+
+        gk20a_vm_free_entries(vm, &vm->pdb, 0);
+}
+
+/*
+ * Cleanup the VM but don't nvgpu_kfree() on the vm pointer.
+ */
+void __nvgpu_vm_remove(struct vm_gk20a *vm)
 {
         struct nvgpu_mapped_buf *mapped_buffer;
         struct nvgpu_vm_area *vm_area, *vm_area_tmp;
@@ -480,22 +495,40 @@ void nvgpu_vm_remove_support_nofree(struct vm_gk20a *vm)
 
         nvgpu_deinit_vm(vm);
 
+#ifdef CONFIG_TEGRA_GR_VIRTUALIZATION
+        if (g->is_virtual)
+                nvgpu_vm_remove_vgpu(vm);
+#endif
+
         nvgpu_mutex_release(&vm->update_gmmu_lock);
 }
 
-void nvgpu_vm_remove_support(struct vm_gk20a *vm)
+/*
+ * Remove and nvgpu_kfree() the VM struct.
+ */
+void nvgpu_vm_remove(struct vm_gk20a *vm)
 {
-        nvgpu_vm_remove_support_nofree(vm);
-        /* vm is not used anymore. release it. */
+        __nvgpu_vm_remove(vm);
+
         nvgpu_kfree(vm->mm->g, vm);
 }
 
-static void nvgpu_vm_remove_support_kref(struct kref *ref)
+/*
+ * Note: this does not nvgpu_kfree() the vm. This might be a bug.
+ */
+void nvgpu_vm_remove_inst(struct vm_gk20a *vm, struct nvgpu_mem *inst_block)
+{
+        struct gk20a *g = vm->mm->g;
+
+        gk20a_free_inst_block(g, inst_block);
+        __nvgpu_vm_remove(vm);
+}
+
+static void __nvgpu_vm_remove_kref(struct kref *ref)
 {
         struct vm_gk20a *vm = container_of(ref, struct vm_gk20a, ref);
-        struct gk20a *g = gk20a_from_vm(vm);
 
-        g->ops.mm.vm_remove(vm);
+        nvgpu_vm_remove(vm);
 }
 
 void nvgpu_vm_get(struct vm_gk20a *vm)
@@ -505,15 +538,7 @@ void nvgpu_vm_get(struct vm_gk20a *vm)
 
 void nvgpu_vm_put(struct vm_gk20a *vm)
 {
-        kref_put(&vm->ref, nvgpu_vm_remove_support_kref);
-}
-
-void nvgpu_vm_remove(struct vm_gk20a *vm, struct nvgpu_mem *inst_block)
-{
-        struct gk20a *g = vm->mm->g;
-
-        gk20a_free_inst_block(g, inst_block);
-        nvgpu_vm_remove_support_nofree(vm);
+        kref_put(&vm->ref, __nvgpu_vm_remove_kref);
 }
 
 int nvgpu_insert_mapped_buf(struct vm_gk20a *vm,
diff --git a/drivers/gpu/nvgpu/gk20a/dbg_gpu_gk20a.c b/drivers/gpu/nvgpu/gk20a/dbg_gpu_gk20a.c
index 82bf7b3e..1f9b856d 100644
--- a/drivers/gpu/nvgpu/gk20a/dbg_gpu_gk20a.c
+++ b/drivers/gpu/nvgpu/gk20a/dbg_gpu_gk20a.c
@@ -1924,7 +1924,7 @@ static int gk20a_perfbuf_map(struct dbg_session_gk20a *dbg_s,
 err_unmap:
         nvgpu_vm_unmap_buffer(vm, args->offset, NULL);
 err_remove_vm:
-        nvgpu_vm_remove(vm, &mm->perfbuf.inst_block);
+        nvgpu_vm_remove_inst(vm, &mm->perfbuf.inst_block);
         nvgpu_mutex_release(&g->dbg_sessions_lock);
         return err;
 }
@@ -1962,7 +1962,7 @@ static int gk20a_perfbuf_release_locked(struct gk20a *g, u64 offset)
         err = gk20a_perfbuf_disable_locked(g);
 
         nvgpu_vm_unmap_buffer(vm, offset, NULL);
-        nvgpu_vm_remove(vm, &mm->perfbuf.inst_block);
+        nvgpu_vm_remove_inst(vm, &mm->perfbuf.inst_block);
 
         g->perfbuf.owner = NULL;
         g->perfbuf.offset = 0;
diff --git a/drivers/gpu/nvgpu/gk20a/gk20a.h b/drivers/gpu/nvgpu/gk20a/gk20a.h
index a8837433..ceadbae2 100644
--- a/drivers/gpu/nvgpu/gk20a/gk20a.h
+++ b/drivers/gpu/nvgpu/gk20a/gk20a.h
@@ -651,7 +651,6 @@ struct gpu_ops {
                                 int rw_flag,
                                 bool sparse,
                                 struct vm_gk20a_mapping_batch *batch);
-                void (*vm_remove)(struct vm_gk20a *vm);
                 int (*vm_alloc_share)(struct gk20a_as_share *as_share,
                                       u32 big_page_size, u32 flags);
                 int (*vm_bind_channel)(struct gk20a_as_share *as_share,
diff --git a/drivers/gpu/nvgpu/gk20a/mm_gk20a.c b/drivers/gpu/nvgpu/gk20a/mm_gk20a.c
index 17f1622f..183a540a 100644
--- a/drivers/gpu/nvgpu/gk20a/mm_gk20a.c
+++ b/drivers/gpu/nvgpu/gk20a/mm_gk20a.c
@@ -464,7 +464,7 @@ static void gk20a_remove_mm_ce_support(struct mm_gk20a *mm)
 
         mm->vidmem.ce_ctx_id = (u32)~0;
 
-        nvgpu_vm_remove_support_nofree(&mm->ce.vm);
+        __nvgpu_vm_remove(&mm->ce.vm);
 
 }
 
@@ -476,11 +476,11 @@ static void gk20a_remove_mm_support(struct mm_gk20a *mm)
                 g->ops.mm.remove_bar2_vm(g);
 
         if (g->ops.mm.is_bar1_supported(g))
-                nvgpu_vm_remove(&mm->bar1.vm, &mm->bar1.inst_block);
+                nvgpu_vm_remove_inst(&mm->bar1.vm, &mm->bar1.inst_block);
 
-        nvgpu_vm_remove(&mm->pmu.vm, &mm->pmu.inst_block);
+        nvgpu_vm_remove_inst(&mm->pmu.vm, &mm->pmu.inst_block);
         gk20a_free_inst_block(gk20a_from_mm(mm), &mm->hwpm.inst_block);
-        nvgpu_vm_remove_support_nofree(&mm->cde.vm);
+        __nvgpu_vm_remove(&mm->cde.vm);
 
         gk20a_semaphore_sea_destroy(g);
         gk20a_vidmem_destroy(g);
@@ -2337,10 +2337,9 @@ void nvgpu_vm_unmap_locked(struct nvgpu_mapped_buf *mapped_buffer,
         return;
 }
 
-
-static void gk20a_vm_free_entries(struct vm_gk20a *vm,
-                                  struct gk20a_mm_entry *parent,
-                                  int level)
+void gk20a_vm_free_entries(struct vm_gk20a *vm,
+                           struct gk20a_mm_entry *parent,
+                           int level)
 {
         int i;
 
@@ -2663,18 +2662,6 @@ int nvgpu_vm_unmap_buffer(struct vm_gk20a *vm, u64 offset,
         return 0;
 }
 
-void nvgpu_deinit_vm(struct vm_gk20a *vm)
-{
-        if (nvgpu_alloc_initialized(&vm->kernel))
-                nvgpu_alloc_destroy(&vm->kernel);
-        if (nvgpu_alloc_initialized(&vm->user))
-                nvgpu_alloc_destroy(&vm->user);
-        if (nvgpu_alloc_initialized(&vm->user_lp))
-                nvgpu_alloc_destroy(&vm->user_lp);
-
-        gk20a_vm_free_entries(vm, &vm->pdb, 0);
-}
-
 int gk20a_alloc_inst_block(struct gk20a *g, struct nvgpu_mem *inst_block)
 {
         int err;
@@ -3151,7 +3138,6 @@ void gk20a_init_mm(struct gpu_ops *gops)
 {
         gops->mm.gmmu_map = gk20a_locked_gmmu_map;
         gops->mm.gmmu_unmap = gk20a_locked_gmmu_unmap;
-        gops->mm.vm_remove = nvgpu_vm_remove_support;
         gops->mm.vm_alloc_share = gk20a_vm_alloc_share;
         gops->mm.vm_bind_channel = gk20a_vm_bind_channel;
         gops->mm.fb_flush = gk20a_mm_fb_flush;
diff --git a/drivers/gpu/nvgpu/gk20a/mm_gk20a.h b/drivers/gpu/nvgpu/gk20a/mm_gk20a.h
index 90a72811..4adf346e 100644
--- a/drivers/gpu/nvgpu/gk20a/mm_gk20a.h
+++ b/drivers/gpu/nvgpu/gk20a/mm_gk20a.h
@@ -463,4 +463,8 @@ int gk20a_mm_get_buffer_info(struct device *dev, int dmabuf_fd,
                              u64 *buffer_id, u64 *buffer_len);
 void gk20a_vm_unmap_locked_kref(struct kref *ref);
 
+void gk20a_vm_free_entries(struct vm_gk20a *vm,
+                           struct gk20a_mm_entry *parent,
+                           int level);
+
 #endif /* MM_GK20A_H */
diff --git a/drivers/gpu/nvgpu/gm20b/mm_gm20b.c b/drivers/gpu/nvgpu/gm20b/mm_gm20b.c
index 1405ef30..78e083d0 100644
--- a/drivers/gpu/nvgpu/gm20b/mm_gm20b.c
+++ b/drivers/gpu/nvgpu/gm20b/mm_gm20b.c
@@ -60,7 +60,6 @@ void gm20b_init_mm(struct gpu_ops *gops)
         gops->mm.support_sparse = gm20b_mm_support_sparse;
         gops->mm.gmmu_map = gk20a_locked_gmmu_map;
         gops->mm.gmmu_unmap = gk20a_locked_gmmu_unmap;
-        gops->mm.vm_remove = nvgpu_vm_remove_support;
         gops->mm.vm_alloc_share = gk20a_vm_alloc_share;
         gops->mm.vm_bind_channel = gk20a_vm_bind_channel;
         gops->mm.fb_flush = gk20a_mm_fb_flush;
diff --git a/drivers/gpu/nvgpu/gp10b/mm_gp10b.c b/drivers/gpu/nvgpu/gp10b/mm_gp10b.c
index 6acea549..bc4aee3a 100644
--- a/drivers/gpu/nvgpu/gp10b/mm_gp10b.c
+++ b/drivers/gpu/nvgpu/gp10b/mm_gp10b.c
@@ -401,7 +401,7 @@ static void gp10b_remove_bar2_vm(struct gk20a *g)
         struct mm_gk20a *mm = &g->mm;
 
         gp10b_replayable_pagefault_buffer_deinit(g);
-        nvgpu_vm_remove(&mm->bar2.vm, &mm->bar2.inst_block);
+        nvgpu_vm_remove_inst(&mm->bar2.vm, &mm->bar2.inst_block);
 }
 
 
diff --git a/drivers/gpu/nvgpu/include/nvgpu/vm.h b/drivers/gpu/nvgpu/include/nvgpu/vm.h
index c89282bf..fed58f24 100644
--- a/drivers/gpu/nvgpu/include/nvgpu/vm.h
+++ b/drivers/gpu/nvgpu/include/nvgpu/vm.h
@@ -225,19 +225,22 @@ int nvgpu_insert_mapped_buf(struct vm_gk20a *vm,
 void nvgpu_remove_mapped_buf(struct vm_gk20a *vm,
                              struct nvgpu_mapped_buf *mapped_buffer);
 
-void nvgpu_vm_remove_support_nofree(struct vm_gk20a *vm);
-void nvgpu_vm_remove_support(struct vm_gk20a *vm);
-void nvgpu_vm_remove(struct vm_gk20a *vm, struct nvgpu_mem *inst_block);
+void __nvgpu_vm_remove(struct vm_gk20a *vm);
+void nvgpu_vm_remove(struct vm_gk20a *vm);
+void nvgpu_vm_remove_inst(struct vm_gk20a *vm, struct nvgpu_mem *inst_block);
+#ifdef CONFIG_TEGRA_GR_VIRTUALIZATION
+void nvgpu_vm_remove_vgpu(struct vm_gk20a *vm);
+#endif
 
 int nvgpu_init_vm(struct mm_gk20a *mm,
-                struct vm_gk20a *vm,
-                u32 big_page_size,
-                u64 low_hole,
-                u64 kernel_reserved,
-                u64 aperture_size,
-                bool big_pages,
-                bool userspace_managed,
-                char *name);
+                  struct vm_gk20a *vm,
+                  u32 big_page_size,
+                  u64 low_hole,
+                  u64 kernel_reserved,
+                  u64 aperture_size,
+                  bool big_pages,
+                  bool userspace_managed,
+                  char *name);
 void nvgpu_deinit_vm(struct vm_gk20a *vm);
 
 /*
diff --git a/drivers/gpu/nvgpu/vgpu/mm_vgpu.c b/drivers/gpu/nvgpu/vgpu/mm_vgpu.c
index 63490aa5..db120d76 100644
--- a/drivers/gpu/nvgpu/vgpu/mm_vgpu.c
+++ b/drivers/gpu/nvgpu/vgpu/mm_vgpu.c
@@ -18,6 +18,7 @@
 #include <nvgpu/kmem.h>
 #include <nvgpu/dma.h>
 #include <nvgpu/bug.h>
+#include <nvgpu/vm.h>
 #include <nvgpu/vm_area.h>
 
 #include "vgpu/vgpu.h"
@@ -200,52 +201,18 @@ static void vgpu_locked_gmmu_unmap(struct vm_gk20a *vm,
         /* TLB invalidate handled on server side */
 }
 
-static void vgpu_vm_remove_support(struct vm_gk20a *vm)
+void nvgpu_vm_remove_vgpu(struct vm_gk20a *vm)
 {
-        struct gk20a *g = vm->mm->g;
-        struct nvgpu_mapped_buf *mapped_buffer;
-        struct nvgpu_vm_area *vm_area, *vm_area_tmp;
+        struct gk20a *g = gk20a_from_vm(vm);
         struct tegra_vgpu_cmd_msg msg;
         struct tegra_vgpu_as_share_params *p = &msg.params.as_share;
-        struct nvgpu_rbtree_node *node = NULL;
         int err;
 
-        gk20a_dbg_fn("");
-        nvgpu_mutex_acquire(&vm->update_gmmu_lock);
-
-        /* TBD: add a flag here for the unmap code to recognize teardown
-         * and short-circuit any otherwise expensive operations. */
-
-        nvgpu_rbtree_enum_start(0, &node, vm->mapped_buffers);
-        while (node) {
-                mapped_buffer = mapped_buffer_from_rbtree_node(node);
-                nvgpu_vm_unmap_locked(mapped_buffer, NULL);
-                nvgpu_rbtree_enum_start(0, &node, vm->mapped_buffers);
-        }
-
-        /* destroy remaining reserved memory areas */
-        nvgpu_list_for_each_entry_safe(vm_area, vm_area_tmp,
-                        &vm->vm_area_list,
-                        nvgpu_vm_area, vm_area_list) {
-                nvgpu_list_del(&vm_area->vm_area_list);
-                nvgpu_kfree(g, vm_area);
-        }
-
         msg.cmd = TEGRA_VGPU_CMD_AS_FREE_SHARE;
         msg.handle = vgpu_get_handle(g);
         p->handle = vm->handle;
         err = vgpu_comm_sendrecv(&msg, sizeof(msg), sizeof(msg));
         WARN_ON(err || msg.ret);
-
-        if (nvgpu_alloc_initialized(&vm->kernel))
-                nvgpu_alloc_destroy(&vm->kernel);
-        if (nvgpu_alloc_initialized(&vm->user))
-                nvgpu_alloc_destroy(&vm->user);
-
-        nvgpu_mutex_release(&vm->update_gmmu_lock);
-
-        /* vm is not used anymore. release it. */
-        nvgpu_kfree(g, vm);
 }
 
 u64 vgpu_bar1_map(struct gk20a *g, struct sg_table **sgt, u64 size)
@@ -534,7 +501,6 @@ void vgpu_init_mm_ops(struct gpu_ops *gops)
         gops->fb.set_debug_mode = vgpu_mm_mmu_set_debug_mode;
         gops->mm.gmmu_map = vgpu_locked_gmmu_map;
         gops->mm.gmmu_unmap = vgpu_locked_gmmu_unmap;
-        gops->mm.vm_remove = vgpu_vm_remove_support;
         gops->mm.vm_alloc_share = vgpu_vm_alloc_share;
         gops->mm.vm_bind_channel = vgpu_vm_bind_channel;
         gops->mm.fb_flush = vgpu_mm_fb_flush;