5 files changed, 87 insertions, 92 deletions

diff --git a/drivers/gpu/nvgpu/gk20a/channel_gk20a.c b/drivers/gpu/nvgpu/gk20a/channel_gk20a.c
index c09539ff..26fbd66e 100644
--- a/drivers/gpu/nvgpu/gk20a/channel_gk20a.c
+++ b/drivers/gpu/nvgpu/gk20a/channel_gk20a.c
@@ -26,7 +26,6 @@
 #include <linux/file.h>
 #include <linux/anon_inodes.h>
 #include <linux/dma-buf.h>
-#include <linux/vmalloc.h>
 #include <linux/circ_buf.h>
 
 #include <nvgpu/semaphore.h>
@@ -1244,7 +1243,7 @@ int gk20a_channel_release(struct inode *inode, struct file *filp)
 
 channel_release:
         gk20a_put(g);
-        kfree(filp->private_data);
+        nvgpu_kfree(g, filp->private_data);
         filp->private_data = NULL;
         return 0;
 }
@@ -1390,7 +1389,7 @@ static int __gk20a_channel_open(struct gk20a *g, struct file *filp, s32 runlist_
 
         trace_gk20a_channel_open(dev_name(g->dev));
 
-        priv = kzalloc(sizeof(*priv), GFP_KERNEL);
+        priv = nvgpu_kzalloc(g, sizeof(*priv));
         if (!priv) {
                 err = -ENOMEM;
                 goto free_ref;
@@ -1421,7 +1420,7 @@ static int __gk20a_channel_open(struct gk20a *g, struct file *filp, s32 runlist_
         return 0;
 
 fail_busy:
-        kfree(priv);
+        nvgpu_kfree(g, priv);
 free_ref:
         gk20a_put(g);
         return err;
@@ -1446,7 +1445,7 @@ int gk20a_channel_open_ioctl(struct gk20a *g,
         int err;
         int fd;
         struct file *file;
-        char *name;
+        char name[64];
         s32 runlist_id = args->in.runlist_id;
 
         err = get_unused_fd_flags(O_RDWR);
@@ -1454,15 +1453,10 @@ int gk20a_channel_open_ioctl(struct gk20a *g,
                 return err;
         fd = err;
 
-        name = kasprintf(GFP_KERNEL, "nvhost-%s-fd%d",
-                        dev_name(g->dev), fd);
-        if (!name) {
-                err = -ENOMEM;
-                goto clean_up;
-        }
+        snprintf(name, sizeof(name), "nvhost-%s-fd%d",
+                 dev_name(g->dev), fd);
 
         file = anon_inode_getfile(name, g->channel.cdev.ops, NULL, O_RDWR);
-        kfree(name);
         if (IS_ERR(file)) {
                 err = PTR_ERR(file);
                 goto clean_up;
@@ -1609,7 +1603,7 @@ static void free_priv_cmdbuf(struct channel_gk20a *c,
         if (channel_gk20a_is_prealloc_enabled(c))
                 memset(e, 0, sizeof(struct priv_cmd_entry));
         else
-                kfree(e);
+                nvgpu_kfree(c->g, e);
 }
 
 static int channel_gk20a_alloc_job(struct channel_gk20a *c,
@@ -1635,8 +1629,8 @@ static int channel_gk20a_alloc_job(struct channel_gk20a *c,
                         err = -EAGAIN;
                 }
         } else {
-                *job_out = kzalloc(sizeof(struct channel_gk20a_job),
-                                GFP_KERNEL);
+                *job_out = nvgpu_kzalloc(c->g,
+                                         sizeof(struct channel_gk20a_job));
                 if (!*job_out)
                         err = -ENOMEM;
         }
@@ -1659,7 +1653,7 @@ static void channel_gk20a_free_job(struct channel_gk20a *c,
                 job->wait_cmd = wait_cmd;
                 job->incr_cmd = incr_cmd;
         } else
-                kfree(job);
+                nvgpu_kfree(c->g, job);
 }
 
 void channel_gk20a_joblist_lock(struct channel_gk20a *c)
@@ -1757,7 +1751,8 @@ static int channel_gk20a_prealloc_resources(struct channel_gk20a *c,
          */
         size = sizeof(struct channel_gk20a_job);
         if (num_jobs <= ULONG_MAX / size)
-                c->joblist.pre_alloc.jobs = vzalloc(num_jobs * size);
+                c->joblist.pre_alloc.jobs = nvgpu_vzalloc(c->g,
+                                                          num_jobs * size);
         if (!c->joblist.pre_alloc.jobs) {
                 err = -ENOMEM;
                 goto clean_up;
@@ -1770,7 +1765,7 @@ static int channel_gk20a_prealloc_resources(struct channel_gk20a *c,
          */
         size = sizeof(struct priv_cmd_entry);
         if (num_jobs <= ULONG_MAX / (size << 1))
-                entries = vzalloc((num_jobs << 1) * size);
+                entries = nvgpu_vzalloc(c->g, (num_jobs << 1) * size);
         if (!entries) {
                 err = -ENOMEM;
                 goto clean_up_joblist;
@@ -1799,9 +1794,9 @@ static int channel_gk20a_prealloc_resources(struct channel_gk20a *c,
         return 0;
 
 clean_up_priv_cmd:
-        vfree(entries);
+        nvgpu_vfree(c->g, entries);
 clean_up_joblist:
-        vfree(c->joblist.pre_alloc.jobs);
+        nvgpu_vfree(c->g, c->joblist.pre_alloc.jobs);
 clean_up:
         memset(&c->joblist.pre_alloc, 0, sizeof(c->joblist.pre_alloc));
         return err;
@@ -1809,8 +1804,8 @@ clean_up:
 
 static void channel_gk20a_free_prealloc_resources(struct channel_gk20a *c)
 {
-        vfree(c->joblist.pre_alloc.jobs[0].wait_cmd);
-        vfree(c->joblist.pre_alloc.jobs);
+        nvgpu_vfree(c->g, c->joblist.pre_alloc.jobs[0].wait_cmd);
+        nvgpu_vfree(c->g, c->joblist.pre_alloc.jobs);
         gk20a_free_fence_pool(c);
 
         /*
@@ -2910,8 +2905,8 @@ static int gk20a_submit_prepare_syncs(struct channel_gk20a *c,
                 }
 
                 if (!pre_alloc_enabled)
-                        job->wait_cmd = kzalloc(sizeof(struct priv_cmd_entry),
-                                                GFP_KERNEL);
+                        job->wait_cmd = nvgpu_kzalloc(g,
+                                sizeof(struct priv_cmd_entry));
 
                 if (!job->wait_cmd) {
                         err = -ENOMEM;
@@ -2951,8 +2946,7 @@ static int gk20a_submit_prepare_syncs(struct channel_gk20a *c,
                 goto clean_up_wait_cmd;
         }
         if (!pre_alloc_enabled)
-                job->incr_cmd = kzalloc(sizeof(struct priv_cmd_entry),
-                                        GFP_KERNEL);
+                job->incr_cmd = nvgpu_kzalloc(g, sizeof(struct priv_cmd_entry));
 
         if (!job->incr_cmd) {
                 err = -ENOMEM;
@@ -3520,7 +3514,7 @@ static int gk20a_event_id_release(struct inode *inode, struct file *filp)
 
         nvgpu_mutex_destroy(&event_id_data->lock);
         gk20a_put(g);
-        kfree(event_id_data);
+        nvgpu_kfree(g, event_id_data);
         filp->private_data = NULL;
 
         return 0;
@@ -3588,7 +3582,7 @@ static int gk20a_channel_event_id_enable(struct channel_gk20a *ch,
         int err = 0;
         int local_fd;
         struct file *file;
-        char *name;
+        char name[64];
         struct gk20a_event_id_data *event_id_data;
 
         g = gk20a_get(ch->g);
@@ -3608,18 +3602,16 @@ static int gk20a_channel_event_id_enable(struct channel_gk20a *ch,
                 goto free_ref;
         local_fd = err;
 
-        name = kasprintf(GFP_KERNEL, "nvgpu-event%d-fd%d",
-                        event_id, local_fd);
-
+        snprintf(name, sizeof(name), "nvgpu-event%d-fd%d",
+                 event_id, local_fd);
         file = anon_inode_getfile(name, &gk20a_event_id_ops,
                                   NULL, O_RDWR);
-        kfree(name);
         if (IS_ERR(file)) {
                 err = PTR_ERR(file);
                 goto clean_up;
         }
 
-        event_id_data = kzalloc(sizeof(*event_id_data), GFP_KERNEL);
+        event_id_data = nvgpu_kzalloc(ch->g, sizeof(*event_id_data));
         if (!event_id_data) {
                 err = -ENOMEM;
                 goto clean_up_file;
diff --git a/drivers/gpu/nvgpu/gk20a/channel_sync_gk20a.c b/drivers/gpu/nvgpu/gk20a/channel_sync_gk20a.c
index b4870c33..11448094 100644
--- a/drivers/gpu/nvgpu/gk20a/channel_sync_gk20a.c
+++ b/drivers/gpu/nvgpu/gk20a/channel_sync_gk20a.c
@@ -19,6 +19,7 @@
 #include <linux/version.h>
 
 #include <nvgpu/semaphore.h>
+#include <nvgpu/kmem.h>
 
 #include "channel_sync_gk20a.h"
 #include "gk20a.h"
@@ -339,7 +340,7 @@ static void gk20a_channel_syncpt_destroy(struct gk20a_channel_sync *s)
                 container_of(s, struct gk20a_channel_syncpt, ops);
         nvhost_syncpt_set_min_eq_max_ext(sp->host1x_pdev, sp->id);
         nvhost_syncpt_put_ref_ext(sp->host1x_pdev, sp->id);
-        kfree(sp);
+        nvgpu_kfree(sp->c->g, sp);
 }
 
 static struct gk20a_channel_sync *
@@ -348,7 +349,7 @@ gk20a_channel_syncpt_create(struct channel_gk20a *c)
         struct gk20a_channel_syncpt *sp;
         char syncpt_name[32];
 
-        sp = kzalloc(sizeof(*sp), GFP_KERNEL);
+        sp = nvgpu_kzalloc(c->g, sizeof(*sp));
         if (!sp)
                 return NULL;
 
@@ -361,7 +362,7 @@ gk20a_channel_syncpt_create(struct channel_gk20a *c)
         sp->id = nvhost_get_syncpt_host_managed(sp->host1x_pdev,
                                                 c->hw_chid, syncpt_name);
         if (!sp->id) {
-                kfree(sp);
+                nvgpu_kfree(c->g, sp);
                 gk20a_err(c->g->dev, "failed to get free syncpt");
                 return NULL;
         }
@@ -464,12 +465,13 @@ void gk20a_channel_cancel_pending_sema_waits(struct gk20a *g)
                 list_del_init(&work->entry);
 
                 /*
-                 * Only kfree() work if the cancel is successful. Otherwise it's
-                 * in use by the gk20a_channel_semaphore_launcher() code.
+                 * Only nvgpu_kfree() work if the cancel is successful.
+                 * Otherwise it's in use by the
+                 * gk20a_channel_semaphore_launcher() code.
                  */
                 ret = sync_fence_cancel_async(work->fence, &work->waiter);
                 if (ret == 0)
-                        kfree(work);
+                        nvgpu_kfree(g, work);
         }
 }
 
@@ -503,7 +505,7 @@ static void gk20a_channel_semaphore_launcher(
         sync_fence_put(fence);
         nvgpu_semaphore_release(w->sema);
         nvgpu_semaphore_put(w->sema);
-        kfree(w);
+        nvgpu_kfree(g, w);
 }
 #endif
 
@@ -706,7 +708,7 @@ static int gk20a_channel_semaphore_wait_fd(
                 goto clean_up_sync_fence;
         }
 
-        w = kzalloc(sizeof(*w), GFP_KERNEL);
+        w = nvgpu_kzalloc(c->g, sizeof(*w));
         if (!w) {
                 err = -ENOMEM;
                 goto clean_up_priv_cmd;
@@ -766,7 +768,7 @@ clean_up_sema:
         nvgpu_semaphore_put(w->sema);
         nvgpu_semaphore_put(w->sema);
 clean_up_worker:
-        kfree(w);
+        nvgpu_kfree(c->g, w);
 clean_up_priv_cmd:
         gk20a_free_priv_cmdbuf(c, entry);
 clean_up_sync_fence:
@@ -917,7 +919,7 @@ static void gk20a_channel_semaphore_destroy(struct gk20a_channel_sync *s)
         /* The sema pool is cleaned up by the VM destroy. */
         sema->pool = NULL;
 
-        kfree(sema);
+        nvgpu_kfree(sema->c->g, sema);
 }
 
 static struct gk20a_channel_sync *
@@ -930,7 +932,7 @@ gk20a_channel_semaphore_create(struct channel_gk20a *c)
         if (WARN_ON(!c->vm))
                 return NULL;
 
-        sema = kzalloc(sizeof(*sema), GFP_KERNEL);
+        sema = nvgpu_kzalloc(c->g, sizeof(*sema));
         if (!sema)
                 return NULL;
         sema->c = c;
diff --git a/drivers/gpu/nvgpu/gk20a/fifo_gk20a.c b/drivers/gpu/nvgpu/gk20a/fifo_gk20a.c
index 2fa939b9..b390daa4 100644
--- a/drivers/gpu/nvgpu/gk20a/fifo_gk20a.c
+++ b/drivers/gpu/nvgpu/gk20a/fifo_gk20a.c
@@ -18,7 +18,6 @@
  */
 
 #include <linux/delay.h>
-#include <linux/slab.h>
 #include <linux/scatterlist.h>
 #include <trace/events/gk20a.h>
 #include <linux/dma-mapping.h>
@@ -27,6 +26,7 @@
 
 #include <nvgpu/timers.h>
 #include <nvgpu/semaphore.h>
+#include <nvgpu/kmem.h>
 
 #include "gk20a.h"
 #include "debug_gk20a.h"
@@ -483,10 +483,10 @@ void gk20a_fifo_delete_runlist(struct fifo_gk20a *f)
                         gk20a_gmmu_free(g, &runlist->mem[i]);
                 }
 
-                kfree(runlist->active_channels);
+                nvgpu_kfree(g, runlist->active_channels);
                 runlist->active_channels = NULL;
 
-                kfree(runlist->active_tsgs);
+                nvgpu_kfree(g, runlist->active_tsgs);
                 runlist->active_tsgs = NULL;
 
                 nvgpu_mutex_destroy(&runlist->mutex);
@@ -495,7 +495,7 @@ void gk20a_fifo_delete_runlist(struct fifo_gk20a *f)
         memset(f->runlist_info, 0, (sizeof(struct fifo_runlist_info_gk20a) *
                 f->max_runlists));
 
-        kfree(f->runlist_info);
+        nvgpu_kfree(g, f->runlist_info);
         f->runlist_info = NULL;
         f->max_runlists = 0;
 }
@@ -538,8 +538,8 @@ static void gk20a_remove_fifo_support(struct fifo_gk20a *f)
 
         }
 
-        vfree(f->channel);
-        vfree(f->tsg);
+        nvgpu_vfree(g, f->channel);
+        nvgpu_vfree(g, f->tsg);
         if (g->ops.mm.is_bar1_supported(g))
                 gk20a_gmmu_unmap_free(&g->mm.bar1.vm, &f->userd);
         else
@@ -547,11 +547,11 @@ static void gk20a_remove_fifo_support(struct fifo_gk20a *f)
 
         gk20a_fifo_delete_runlist(f);
 
-        kfree(f->pbdma_map);
+        nvgpu_kfree(g, f->pbdma_map);
         f->pbdma_map = NULL;
-        kfree(f->engine_info);
+        nvgpu_kfree(g, f->engine_info);
         f->engine_info = NULL;
-        kfree(f->active_engines_list);
+        nvgpu_kfree(g, f->active_engines_list);
         f->active_engines_list = NULL;
 #ifdef CONFIG_DEBUG_FS
         nvgpu_mutex_acquire(&f->profile.lock);
@@ -654,8 +654,9 @@ static int init_runlist(struct gk20a *g, struct fifo_gk20a *f)
         gk20a_dbg_fn("");
 
         f->max_runlists = g->ops.fifo.eng_runlist_base_size();
-        f->runlist_info = kzalloc(sizeof(struct fifo_runlist_info_gk20a) *
-                                  f->max_runlists, GFP_KERNEL);
+        f->runlist_info = nvgpu_kzalloc(g,
+                                        sizeof(struct fifo_runlist_info_gk20a) *
+                                        f->max_runlists);
         if (!f->runlist_info)
                 goto clean_up_runlist;
 
@@ -666,14 +667,14 @@ static int init_runlist(struct gk20a *g, struct fifo_gk20a *f)
                 runlist = &f->runlist_info[runlist_id];
 
                 runlist->active_channels =
-                        kzalloc(DIV_ROUND_UP(f->num_channels, BITS_PER_BYTE),
-                                GFP_KERNEL);
+                        nvgpu_kzalloc(g, DIV_ROUND_UP(f->num_channels,
+                                                      BITS_PER_BYTE));
                 if (!runlist->active_channels)
                         goto clean_up_runlist;
 
                 runlist->active_tsgs =
-                        kzalloc(DIV_ROUND_UP(f->num_channels, BITS_PER_BYTE),
-                                GFP_KERNEL);
+                        nvgpu_kzalloc(g, DIV_ROUND_UP(f->num_channels,
+                                                      BITS_PER_BYTE));
                 if (!runlist->active_tsgs)
                         goto clean_up_runlist;
 
@@ -905,16 +906,14 @@ static int gk20a_init_fifo_setup_sw(struct gk20a *g)
 
         f->userd_entry_size = 1 << ram_userd_base_shift_v();
 
-        f->channel = vzalloc(f->num_channels * sizeof(*f->channel));
-        f->tsg = vzalloc(f->num_channels * sizeof(*f->tsg));
-        f->pbdma_map = kzalloc(f->num_pbdma * sizeof(*f->pbdma_map),
-                                GFP_KERNEL);
-        f->engine_info = kzalloc(f->max_engines * sizeof(*f->engine_info),
-                                GFP_KERNEL);
-        f->active_engines_list = kzalloc(f->max_engines * sizeof(u32),
-                                GFP_KERNEL);
+        f->channel = nvgpu_vzalloc(g, f->num_channels * sizeof(*f->channel));
+        f->tsg = nvgpu_vzalloc(g, f->num_channels * sizeof(*f->tsg));
+        f->pbdma_map = nvgpu_kzalloc(g, f->num_pbdma * sizeof(*f->pbdma_map));
+        f->engine_info = nvgpu_kzalloc(g, f->max_engines *
+                                sizeof(*f->engine_info));
+        f->active_engines_list = nvgpu_kzalloc(g, f->max_engines * sizeof(u32));
 
-        if (!(f->channel && f->pbdma_map && f->engine_info &&
+        if (!(f->channel && f->tsg && f->pbdma_map && f->engine_info &&
                 f->active_engines_list)) {
                 err = -ENOMEM;
                 goto clean_up;
@@ -977,15 +976,15 @@ clean_up:
         else
                 gk20a_gmmu_free(g, &f->userd);
 
-        vfree(f->channel);
+        nvgpu_vfree(g, f->channel);
         f->channel = NULL;
-        vfree(f->tsg);
+        nvgpu_vfree(g, f->tsg);
         f->tsg = NULL;
-        kfree(f->pbdma_map);
+        nvgpu_kfree(g, f->pbdma_map);
         f->pbdma_map = NULL;
-        kfree(f->engine_info);
+        nvgpu_kfree(g, f->engine_info);
         f->engine_info = NULL;
-        kfree(f->active_engines_list);
+        nvgpu_kfree(g, f->active_engines_list);
         f->active_engines_list = NULL;
 
         return err;
diff --git a/drivers/gpu/nvgpu/gk20a/sched_gk20a.c b/drivers/gpu/nvgpu/gk20a/sched_gk20a.c
index a73e7993..6b372489 100644
--- a/drivers/gpu/nvgpu/gk20a/sched_gk20a.c
+++ b/drivers/gpu/nvgpu/gk20a/sched_gk20a.c
@@ -12,7 +12,6 @@
  */
 
 #include <asm/barrier.h>
-#include <linux/slab.h>
 #include <linux/kthread.h>
 #include <linux/circ_buf.h>
 #include <linux/delay.h>
@@ -24,6 +23,8 @@
 #include <linux/log2.h>
 #include <uapi/linux/nvgpu.h>
 
+#include <nvgpu/kmem.h>
+
 #include "ctxsw_trace_gk20a.h"
 #include "gk20a.h"
 #include "gr_gk20a.h"
@@ -154,7 +155,7 @@ static int gk20a_sched_dev_ioctl_get_tsgs_by_pid(struct gk20a_sched_ctrl *sched,
                 return -ENOSPC;
         }
 
-        bitmap = kzalloc(sched->bitmap_size, GFP_KERNEL);
+        bitmap = nvgpu_kzalloc(sched->g, sched->bitmap_size);
         if (!bitmap)
                 return -ENOMEM;
 
@@ -172,7 +173,7 @@ static int gk20a_sched_dev_ioctl_get_tsgs_by_pid(struct gk20a_sched_ctrl *sched,
                 bitmap, sched->bitmap_size))
                 err = -EFAULT;
 
-        kfree(bitmap);
+        nvgpu_kfree(sched->g, bitmap);
 
         return err;
 }
@@ -650,15 +651,15 @@ int gk20a_sched_ctrl_init(struct gk20a *g)
         gk20a_dbg(gpu_dbg_fn | gpu_dbg_sched, "g=%p sched=%p size=%zu",
                         g, sched, sched->bitmap_size);
 
-        sched->active_tsg_bitmap = kzalloc(sched->bitmap_size, GFP_KERNEL);
+        sched->active_tsg_bitmap = nvgpu_kzalloc(g, sched->bitmap_size);
         if (!sched->active_tsg_bitmap)
                 return -ENOMEM;
 
-        sched->recent_tsg_bitmap = kzalloc(sched->bitmap_size, GFP_KERNEL);
+        sched->recent_tsg_bitmap = nvgpu_kzalloc(g, sched->bitmap_size);
         if (!sched->recent_tsg_bitmap)
                 goto free_active;
 
-        sched->ref_tsg_bitmap = kzalloc(sched->bitmap_size, GFP_KERNEL);
+        sched->ref_tsg_bitmap = nvgpu_kzalloc(g, sched->bitmap_size);
         if (!sched->ref_tsg_bitmap)
                 goto free_recent;
 
@@ -672,10 +673,10 @@ int gk20a_sched_ctrl_init(struct gk20a *g)
         return 0;
 
 free_recent:
-        kfree(sched->recent_tsg_bitmap);
+        nvgpu_kfree(g, sched->recent_tsg_bitmap);
 
 free_active:
-        kfree(sched->active_tsg_bitmap);
+        nvgpu_kfree(g, sched->active_tsg_bitmap);
 
         return -ENOMEM;
 }
@@ -684,9 +685,9 @@ void gk20a_sched_ctrl_cleanup(struct gk20a *g)
 {
         struct gk20a_sched_ctrl *sched = &g->sched_ctrl;
 
-        kfree(sched->active_tsg_bitmap);
-        kfree(sched->recent_tsg_bitmap);
-        kfree(sched->ref_tsg_bitmap);
+        nvgpu_kfree(g, sched->active_tsg_bitmap);
+        nvgpu_kfree(g, sched->recent_tsg_bitmap);
+        nvgpu_kfree(g, sched->ref_tsg_bitmap);
         sched->active_tsg_bitmap = NULL;
         sched->recent_tsg_bitmap = NULL;
         sched->ref_tsg_bitmap = NULL;
diff --git a/drivers/gpu/nvgpu/gk20a/tsg_gk20a.c b/drivers/gpu/nvgpu/gk20a/tsg_gk20a.c
index 270fed85..21b50700 100644
--- a/drivers/gpu/nvgpu/gk20a/tsg_gk20a.c
+++ b/drivers/gpu/nvgpu/gk20a/tsg_gk20a.c
@@ -22,6 +22,8 @@
 #include <uapi/linux/nvgpu.h>
 #include <linux/anon_inodes.h>
 
+#include <nvgpu/kmem.h>
+
 #include "gk20a.h"
 
 #include <nvgpu/hw/gk20a/hw_ccsr_gk20a.h>
@@ -257,7 +259,7 @@ static int gk20a_tsg_event_id_enable(struct tsg_gk20a *tsg,
         int err = 0;
         int local_fd;
         struct file *file;
-        char *name;
+        char name[64];
         struct gk20a_event_id_data *event_id_data;
         struct gk20a *g;
 
@@ -278,18 +280,17 @@ static int gk20a_tsg_event_id_enable(struct tsg_gk20a *tsg,
                 goto free_ref;
         local_fd = err;
 
-        name = kasprintf(GFP_KERNEL, "nvgpu-event%d-fd%d",
-                        event_id, local_fd);
+        snprintf(name, sizeof(name), "nvgpu-event%d-fd%d",
+                 event_id, local_fd);
 
         file = anon_inode_getfile(name, &gk20a_event_id_ops,
                                   NULL, O_RDWR);
-        kfree(name);
         if (IS_ERR(file)) {
                 err = PTR_ERR(file);
                 goto clean_up;
         }
 
-        event_id_data = kzalloc(sizeof(*event_id_data), GFP_KERNEL);
+        event_id_data = nvgpu_kzalloc(tsg->g, sizeof(*event_id_data));
         if (!event_id_data) {
                 err = -ENOMEM;
                 goto clean_up_file;
@@ -428,7 +429,7 @@ int gk20a_tsg_open(struct gk20a *g, struct file *filp)
 
         gk20a_dbg(gpu_dbg_fn, "tsg: %s", dev_name(dev));
 
-        priv = kmalloc(sizeof(*priv), GFP_KERNEL);
+        priv = nvgpu_kmalloc(g, sizeof(*priv));
         if (!priv) {
                 err = -ENOMEM;
                 goto free_ref;
@@ -436,7 +437,7 @@ int gk20a_tsg_open(struct gk20a *g, struct file *filp)
 
         tsg = acquire_unused_tsg(&g->fifo);
         if (!tsg) {
-                kfree(priv);
+                nvgpu_kfree(g, priv);
                 err = -ENOMEM;
                 goto free_ref;
         }
@@ -533,7 +534,7 @@ int gk20a_tsg_dev_release(struct inode *inode, struct file *filp)
         struct tsg_gk20a *tsg = priv->tsg;
 
         kref_put(&tsg->refcount, gk20a_tsg_release);
-        kfree(priv);
+        nvgpu_kfree(tsg->g, priv);
         return 0;
 }