2 files changed, 33 insertions, 36 deletions

diff --git a/drivers/gpu/nvgpu/common/linux/dma.c b/drivers/gpu/nvgpu/common/linux/dma.c
index b62c4593..9e9d1007 100644
--- a/drivers/gpu/nvgpu/common/linux/dma.c
+++ b/drivers/gpu/nvgpu/common/linux/dma.c
@@ -514,7 +514,6 @@ static void nvgpu_dma_free_sys(struct gk20a *g, struct nvgpu_mem *mem)
 static void nvgpu_dma_free_vid(struct gk20a *g, struct nvgpu_mem *mem)
 {
 #if defined(CONFIG_GK20A_VIDMEM)
-        bool was_empty;
         size_t mem_size = mem->size;
 
         dma_dbg_free(g, mem->size, mem->priv.flags, "vidmem");
@@ -523,18 +522,19 @@ static void nvgpu_dma_free_vid(struct gk20a *g, struct nvgpu_mem *mem)
         WARN_ON(mem->priv.flags != NVGPU_DMA_NO_KERNEL_MAPPING);
 
         if (mem->mem_flags & NVGPU_MEM_FLAG_USER_MEM) {
-                nvgpu_mutex_acquire(&g->mm.vidmem.clear_list_mutex);
-                was_empty = nvgpu_list_empty(&g->mm.vidmem.clear_list_head);
-                nvgpu_list_add_tail(&mem->clear_list_entry,
-                              &g->mm.vidmem.clear_list_head);
-                atomic64_add(mem->aligned_size,
-                             &g->mm.vidmem.bytes_pending.atomic_var);
-                nvgpu_mutex_release(&g->mm.vidmem.clear_list_mutex);
-
-                if (was_empty) {
-                        cancel_work_sync(&g->mm.vidmem.clear_mem_worker);
-                        schedule_work(&g->mm.vidmem.clear_mem_worker);
-                }
+                int err = nvgpu_vidmem_clear_list_enqueue(g, mem);
+
+                /*
+                 * If there's an error here then that means we can't clear the
+                 * vidmem. That's too bad; however, we still own the nvgpu_mem
+                 * buf so we have to free that.
+                 *
+                 * We don't need to worry about the vidmem allocator itself
+                 * since when that gets cleaned up in the driver shutdown path
+                 * all the outstanding allocs are force freed.
+                 */
+                if (err)
+                        nvgpu_kfree(g, mem);
         } else {
                 nvgpu_memset(g, mem, 0, 0, mem->aligned_size);
                 nvgpu_free(mem->allocator,
diff --git a/drivers/gpu/nvgpu/common/linux/vidmem.c b/drivers/gpu/nvgpu/common/linux/vidmem.c
index ea8e552f..92e7e504 100644
--- a/drivers/gpu/nvgpu/common/linux/vidmem.c
+++ b/drivers/gpu/nvgpu/common/linux/vidmem.c
@@ -84,6 +84,8 @@ static void gk20a_vidbuf_release(struct dma_buf *dmabuf)
 
         nvgpu_kfree(g, linux_buf);
         nvgpu_vidmem_buf_free(g, buf);
+
+        gk20a_put(g);
 }
 
 static void *gk20a_vidbuf_kmap(struct dma_buf *dmabuf, unsigned long page_num)
@@ -160,13 +162,21 @@ struct gk20a *nvgpu_vidmem_buf_owner(struct dma_buf *dmabuf)
 
 int nvgpu_vidmem_export_linux(struct gk20a *g, size_t bytes)
 {
-        struct nvgpu_vidmem_buf *buf;
+        struct nvgpu_vidmem_buf *buf = NULL;
         struct nvgpu_vidmem_linux *priv;
         int err, fd;
 
+        /*
+         * This ref is released when the dma_buf is closed.
+         */
+        if (!gk20a_get(g))
+                return -ENODEV;
+
         priv = nvgpu_kzalloc(g, sizeof(*priv));
-        if (!priv)
-                return -ENOMEM;
+        if (!priv) {
+                err = -ENOMEM;
+                goto fail;
+        }
 
         buf = nvgpu_vidmem_user_alloc(g, bytes);
         if (!buf) {
@@ -195,8 +205,10 @@ int nvgpu_vidmem_export_linux(struct gk20a *g, size_t bytes)
         return fd;
 
 fail:
-        nvgpu_kfree(g, priv);
         nvgpu_vidmem_buf_free(g, buf);
+        nvgpu_kfree(g, priv);
+        gk20a_put(g);
+
         return err;
 }
 
@@ -229,24 +241,9 @@ int nvgpu_vidmem_buf_access_memory(struct gk20a *g, struct dma_buf *dmabuf,
         return err;
 }
 
-void nvgpu_vidmem_clear_mem_worker(struct work_struct *work)
+void __nvgpu_mem_free_vidmem_alloc(struct gk20a *g, struct nvgpu_mem *vidmem)
 {
-        struct mm_gk20a *mm = container_of(work, struct mm_gk20a,
-                                        vidmem.clear_mem_worker);
-        struct gk20a *g = mm->g;
-        struct nvgpu_mem *mem;
-
-        while ((mem = nvgpu_vidmem_get_pending_alloc(mm)) != NULL) {
-                nvgpu_vidmem_clear(g, mem);
-                nvgpu_free(mem->allocator,
-                           (u64)nvgpu_vidmem_get_page_alloc(mem->priv.sgt->sgl));
-                nvgpu_free_sgtable(g, &mem->priv.sgt);
-
-                WARN_ON(nvgpu_atomic64_sub_return(mem->aligned_size,
-                                        &g->mm.vidmem.bytes_pending) < 0);
-                mem->size = 0;
-                mem->aperture = APERTURE_INVALID;
-
-                nvgpu_kfree(g, mem);
-        }
+        nvgpu_free(vidmem->allocator,
+                   (u64)nvgpu_vidmem_get_page_alloc(vidmem->priv.sgt->sgl));
+        nvgpu_free_sgtable(g, &vidmem->priv.sgt);
 }