1 files changed, 0 insertions, 653 deletions

diff --git a/include/os/linux/kmem.c b/include/os/linux/kmem.c
deleted file mode 100644
index 395cc45..0000000
--- a/include/os/linux/kmem.c
+++ /dev/null
@@ -1,653 +0,0 @@
-/*
- * Copyright (c) 2017-2018, NVIDIA CORPORATION.  All rights reserved.
- *
- * This program is free software; you can redistribute it and/or modify it
- * under the terms and conditions of the GNU General Public License,
- * version 2, as published by the Free Software Foundation.
- *
- * This program is distributed in the hope it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
- * more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-#include <linux/mm.h>
-#include <linux/slab.h>
-#include <linux/debugfs.h>
-#include <linux/seq_file.h>
-#include <linux/vmalloc.h>
-#include <linux/stacktrace.h>
-
-#include <nvgpu/lock.h>
-#include <nvgpu/kmem.h>
-#include <nvgpu/atomic.h>
-#include <nvgpu/bug.h>
-#include <nvgpu/gk20a.h>
-
-#include "kmem_priv.h"
-
-/*
- * Statically declared because this needs to be shared across all nvgpu driver
- * instances. This makes sure that all kmem caches are _definitely_ uniquely
- * named.
- */
-static atomic_t kmem_cache_id;
-
-void *__nvgpu_big_alloc(struct gk20a *g, size_t size, bool clear)
-{
-        void *p;
-
-        if (size > PAGE_SIZE) {
-                if (clear)
-                        p = nvgpu_vzalloc(g, size);
-                else
-                        p = nvgpu_vmalloc(g, size);
-        } else {
-                if (clear)
-                        p = nvgpu_kzalloc(g, size);
-                else
-                        p = nvgpu_kmalloc(g, size);
-        }
-
-        return p;
-}
-
-void nvgpu_big_free(struct gk20a *g, void *p)
-{
-        /*
-         * This will have to be fixed eventually. Allocs that use
-         * nvgpu_big_[mz]alloc() will need to remember the size of the alloc
-         * when freeing.
-         */
-        if (is_vmalloc_addr(p))
-                nvgpu_vfree(g, p);
-        else
-                nvgpu_kfree(g, p);
-}
-
-void *__nvgpu_kmalloc(struct gk20a *g, size_t size, void *ip)
-{
-        void *alloc;
-
-#ifdef CONFIG_NVGPU_TRACK_MEM_USAGE
-        alloc = __nvgpu_track_kmalloc(g, size, ip);
-#else
-        alloc = kmalloc(size, GFP_KERNEL);
-#endif
-
-        kmem_dbg(g, "kmalloc: size=%-6ld addr=0x%p gfp=0x%08x",
-                 size, alloc, GFP_KERNEL);
-
-        return alloc;
-}
-
-void *__nvgpu_kzalloc(struct gk20a *g, size_t size, void *ip)
-{
-        void *alloc;
-
-#ifdef CONFIG_NVGPU_TRACK_MEM_USAGE
-        alloc = __nvgpu_track_kzalloc(g, size, ip);
-#else
-        alloc = kzalloc(size, GFP_KERNEL);
-#endif
-
-        kmem_dbg(g, "kzalloc: size=%-6ld addr=0x%p gfp=0x%08x",
-                 size, alloc, GFP_KERNEL);
-
-        return alloc;
-}
-
-void *__nvgpu_kcalloc(struct gk20a *g, size_t n, size_t size, void *ip)
-{
-        void *alloc;
-
-#ifdef CONFIG_NVGPU_TRACK_MEM_USAGE
-        alloc = __nvgpu_track_kcalloc(g, n, size, ip);
-#else
-        alloc = kcalloc(n, size, GFP_KERNEL);
-#endif
-
-        kmem_dbg(g, "kcalloc: size=%-6ld addr=0x%p gfp=0x%08x",
-                 n * size, alloc, GFP_KERNEL);
-
-        return alloc;
-}
-
-void *__nvgpu_vmalloc(struct gk20a *g, unsigned long size, void *ip)
-{
-        void *alloc;
-
-#ifdef CONFIG_NVGPU_TRACK_MEM_USAGE
-        alloc = __nvgpu_track_vmalloc(g, size, ip);
-#else
-        alloc = vmalloc(size);
-#endif
-
-        kmem_dbg(g, "vmalloc: size=%-6ld addr=0x%p", size, alloc);
-
-        return alloc;
-}
-
-void *__nvgpu_vzalloc(struct gk20a *g, unsigned long size, void *ip)
-{
-        void *alloc;
-
-#ifdef CONFIG_NVGPU_TRACK_MEM_USAGE
-        alloc = __nvgpu_track_vzalloc(g, size, ip);
-#else
-        alloc = vzalloc(size);
-#endif
-
-        kmem_dbg(g, "vzalloc: size=%-6ld addr=0x%p", size, alloc);
-
-        return alloc;
-}
-
-void __nvgpu_kfree(struct gk20a *g, void *addr)
-{
-        kmem_dbg(g, "kfree: addr=0x%p", addr);
-#ifdef CONFIG_NVGPU_TRACK_MEM_USAGE
-        __nvgpu_track_kfree(g, addr);
-#else
-        kfree(addr);
-#endif
-}
-
-void __nvgpu_vfree(struct gk20a *g, void *addr)
-{
-        kmem_dbg(g, "vfree: addr=0x%p", addr);
-#ifdef CONFIG_NVGPU_TRACK_MEM_USAGE
-        __nvgpu_track_vfree(g, addr);
-#else
-        vfree(addr);
-#endif
-}
-
-#ifdef CONFIG_NVGPU_TRACK_MEM_USAGE
-
-void nvgpu_lock_tracker(struct nvgpu_mem_alloc_tracker *tracker)
-{
-        nvgpu_mutex_acquire(&tracker->lock);
-}
-
-void nvgpu_unlock_tracker(struct nvgpu_mem_alloc_tracker *tracker)
-{
-        nvgpu_mutex_release(&tracker->lock);
-}
-
-void kmem_print_mem_alloc(struct gk20a *g,
-                         struct nvgpu_mem_alloc *alloc,
-                         struct seq_file *s)
-{
-#ifdef __NVGPU_SAVE_KALLOC_STACK_TRACES
-        int i;
-
-        __pstat(s, "nvgpu-alloc: addr=0x%llx size=%ld\n",
-                alloc->addr, alloc->size);
-        for (i = 0; i < alloc->stack_length; i++)
-                __pstat(s, "  %3d [<%p>] %pS\n", i,
-                        (void *)alloc->stack[i],
-                        (void *)alloc->stack[i]);
-        __pstat(s, "\n");
-#else
-        __pstat(s, "nvgpu-alloc: addr=0x%llx size=%ld src=%pF\n",
-                alloc->addr, alloc->size, alloc->ip);
-#endif
-}
-
-static int nvgpu_add_alloc(struct nvgpu_mem_alloc_tracker *tracker,
-                           struct nvgpu_mem_alloc *alloc)
-{
-        alloc->allocs_entry.key_start = alloc->addr;
-        alloc->allocs_entry.key_end = alloc->addr + alloc->size;
-
-        nvgpu_rbtree_insert(&alloc->allocs_entry, &tracker->allocs);
-        return 0;
-}
-
-static struct nvgpu_mem_alloc *nvgpu_rem_alloc(
-        struct nvgpu_mem_alloc_tracker *tracker, u64 alloc_addr)
-{
-        struct nvgpu_mem_alloc *alloc;
-        struct nvgpu_rbtree_node *node = NULL;
-
-        nvgpu_rbtree_search(alloc_addr, &node, tracker->allocs);
-        if (!node)
-                return NULL;
-
-        alloc = nvgpu_mem_alloc_from_rbtree_node(node);
-
-        nvgpu_rbtree_unlink(node, &tracker->allocs);
-
-        return alloc;
-}
-
-static int __nvgpu_save_kmem_alloc(struct nvgpu_mem_alloc_tracker *tracker,
-                                   unsigned long size, unsigned long real_size,
-                                   u64 addr, void *ip)
-{
-        int ret;